abstract class Redis_Lock_DefaultBackend in Redis 7.3

Lock backend shared methods.

Hierarchy

• class \Redis_AbstractBackend implements Redis_BackendInterface
  • class \Redis_Lock_DefaultBackend implements Redis_Lock_BackendInterface

File

lib/Redis/Lock/DefaultBackend.php, line 6

abstract class Redis_Lock_DefaultBackend extends Redis_AbstractBackend implements Redis_Lock_BackendInterface {

  /**
   * Current page lock token identifier.
   *
   * @var string
   */
  protected $_lockId;

  /**
   * Existing locks for this page.
   *
   * @var array
   */
  protected $_locks = array();

  /**
   * Default implementation from actual Drupal core.
   *
   * @see Redis_Lock_BackendInterface::lockWait()
   */
  public function lockWait($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 ($this
        ->lockMayBeAvailable($name)) {

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

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

  /**
   * Default implementation from actual Drupal core.
   *
   * @see Redis_Lock_BackendInterface::getLockId()
   */
  public function getLockId() {
    if (!isset($this->_lockId)) {
      $this->_lockId = uniqid(mt_rand(), TRUE);

      // We only register a shutdown function if a lock is used.
      drupal_register_shutdown_function('lock_release_all', $this->_lockId);
    }
    return $this->_lockId;
  }

  /**
   * Generate a redis key name for the current lock name
   */
  public function getKey($name = null) {
    if (null === $name) {
      return parent::getKey('lock');
    }
    else {
      return parent::getKey(array(
        'lock',
        $name,
      ));
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
Redis_AbstractBackend::$client	private	property
Redis_AbstractBackend::$namespace	private	property
Redis_AbstractBackend::$prefix	private	property
Redis_AbstractBackend::getClient	final public	function	Get client Overrides Redis_BackendInterface::getClient
Redis_AbstractBackend::getNamespace	final public	function	Get namespace Overrides Redis_BackendInterface::getNamespace
Redis_AbstractBackend::getPrefix	final public	function	Get prefix Overrides Redis_BackendInterface::getPrefix
Redis_AbstractBackend::KEY_SEPARATOR		constant	Key components name separator
Redis_AbstractBackend::setClient	final public	function	Set client Overrides Redis_BackendInterface::setClient
Redis_AbstractBackend::setNamespace	final public	function	Set namespace Overrides Redis_BackendInterface::setNamespace
Redis_AbstractBackend::setPrefix	final public	function	Set prefix Overrides Redis_BackendInterface::setPrefix
Redis_AbstractBackend::__construct	public	function	Default constructor	1
Redis_Lock_BackendInterface::lockAcquire	public	function	Acquire lock.	2
Redis_Lock_BackendInterface::lockMayBeAvailable	public	function	Check if lock is available for acquire.	2
Redis_Lock_BackendInterface::lockRelease	public	function	Release given lock.	2
Redis_Lock_BackendInterface::lockReleaseAll	public	function	Release all locks for the given lock token identifier.	2
Redis_Lock_DefaultBackend::$_lockId	protected	property	Current page lock token identifier.
Redis_Lock_DefaultBackend::$_locks	protected	property	Existing locks for this page.
Redis_Lock_DefaultBackend::getKey	public	function	Generate a redis key name for the current lock name Overrides Redis_AbstractBackend::getKey
Redis_Lock_DefaultBackend::getLockId	public	function	Default implementation from actual Drupal core. Overrides Redis_Lock_BackendInterface::getLockId
Redis_Lock_DefaultBackend::lockWait	public	function	Default implementation from actual Drupal core. Overrides Redis_Lock_BackendInterface::lockWait