function lock_wait in Drupal 7

Same name and namespace in other branches

1. 6 includes/lock.inc \lock_wait()
2. 6 includes/lock-install.inc \lock_wait()

Wait for a lock to be available.

This function may be called in a request that fails to acquire a desired lock. This will block further execution until the lock is available or the specified delay in seconds is reached. This should not be used with locks that are acquired very frequently, since the lock is likely to be acquired again by a different request while waiting.

Parameters

$name: The name of the lock.

$delay: The maximum number of seconds to wait, as an integer.

Return value

TRUE if the lock holds, FALSE if it is available.

Related topics

3 calls to lock_wait()

menu_rebuild in includes/menu.inc

Populates the database tables used by various menu functions.

registry_update in includes/bootstrap.inc

Updates the registry based on the latest files listed in the database.

variable_initialize in includes/bootstrap.inc

Loads the persistent variable table.

File

includes/lock.inc, line 203

A database-mediated implementation of a locking mechanism.

Code

function lock_wait($name, $delay = 30) {

  // Pause the process for short periods between calling
  // lock_may_be_available(). This prevents hitting the database with constant
  // database queries while waiting, which could lead to performance issues.
  // However, if the wait period is too long, there is the potential for a
  // large number of processes to be blocked waiting for a lock, especially
  // if the item being rebuilt is commonly requested. To address both of these
  // concerns, begin waiting for 25ms, then add 25ms to the wait period each
  // time until it reaches 500ms. After this point polling will continue every
  // 500ms until $delay is reached.
  // $delay is passed in seconds, but we will be using usleep(), which takes
  // microseconds as a parameter. Multiply it by 1 million so that all
  // further numbers are equivalent.
  $delay = (int) $delay * 1000000;

  // Begin sleeping at 25ms.
  $sleep = 25000;
  while ($delay > 0) {

    // This function should only be called by a request that failed to get a
    // lock, so we sleep first to give the parallel request a chance to finish
    // and release the lock.
    usleep($sleep);

    // After each sleep, increase the value of $sleep until it reaches
    // 500ms, to reduce the potential for a lock stampede.
    $delay = $delay - $sleep;
    $sleep = min(500000, $sleep + 25000, $delay);
    if (lock_may_be_available($name)) {

      // No longer need to wait.
      return FALSE;
    }
  }

  // The caller must still wait longer to get the lock.
  return TRUE;
}