Ausführliche Erläuterung der Codebeispiele für verteilte PHP-Redis-Sperren und Aufgabenwarteschlangen

1. Redis implementiert Ideen für verteilte Sperren

Die wichtigste Redis-Funktion ist setnx(), die zur Implementierung verwendet werden sollte Verteilte Sperren. Die wichtigste Funktion von Sperren. Die erste besteht darin, einen bestimmten Aufgabenidentifikationsnamen (hier wird Lock:order als Identifikationsname verwendet) als Schlüssel in Redis zu speichern und eine Ablaufzeit dafür festzulegen. Wenn eine weitere Lock:order-Anfrage vorliegt, erfolgt der erste Durchgang setnx() Überprüfen Sie, ob Lock:order in Redis eingefügt werden kann. Wenn dies möglich ist, wird true zurückgegeben, wenn nicht, wird false zurückgegeben. Natürlich wird mein Code komplizierter sein als diese Idee, und ich werde ihn bei der Analyse des Codes näher erläutern.

2. Redis implementiert die Aufgabenwarteschlange

Die Implementierung hier verwendet den oben genannten verteilten Redis-Sperrmechanismus, hauptsächlich unter Verwendung der Redis-Datenstruktur bestelltes Set. Wenn Sie beispielsweise der Warteschlange beitreten, können Sie die Funktion add () von zset verwenden, um der Warteschlange beizutreten. Wenn Sie die Warteschlange verlassen, können Sie die Funktion getScore () von zset verwenden. Darüber hinaus können oben mehrere Aufgaben eingeblendet werden.

3. Code-Analyse

(1) Lassen Sie uns zunächst die Code-Implementierung der verteilten Redis-Sperre analysieren　

(1) Um zu vermeiden, dass die Sperre aus besonderen Gründen nicht aufgehoben werden kann, wird der Sperre nach erfolgreicher Sperrung eine Überlebenszeit zugewiesen (durch Parametereinstellung der Sperrmethode oder mit der Standardwert ). Wenn die Überlebenszeit überschritten wird, wird die Sperre standardmäßig kurz aufgehoben (Sekunden). Methode, um die Sperrlebensdauer auf einen geeigneten Zeitpunkt zu verlängern, z. B. in einer Schleife.

(2) Sperren auf Systemebene Wenn der Prozess aus irgendeinem Grund abstürzt, recycelt das Betriebssystem die Sperren selbst, sodass kein Ressourcenverlust auftritt, aber verteilte Sperren werden nicht verwendet Die Zeiteinstellung ist sehr lang. Sobald aus verschiedenen Gründen ein Prozessabsturz oder eine andere Ausnahme auftritt und die Entsperrung nicht aufgerufen wird, wird die Sperre in der verbleibenden Zeit zu einer Müllsperre, was dazu führt, dass andere Prozesse oder Prozesse nicht in die Sperre gelangen können Bereich nach dem Neustart.

Schauen wir uns zunächst den Sperrimplementierungscode an: Hier werden zwei Hauptparameter benötigt, einer ist $timeout, der die Wartezeit für den zyklischen Erwerb der Sperre darstellt. Während dieser Zeit wird weiterhin versucht, die Sperre zu erlangen Bis zur Zeitüberschreitung bedeutet dies, dass die Sperre direkt nach dem Fehlschlagen zurückgegeben werden kann. Dieser Parameter bezieht sich auf die maximale Überlebenszeit der aktuellen Sperre als 0. Wenn die Überlebenszeit überschritten wird, ist die Sperre nicht mehr aktiv. Das System erzwingt automatisch die Freigabe. Die wichtigste Funktion dieses Parameters entnehmen Sie bitte der Erläuterung in (1) oben.

Hier erhalten wir zuerst die aktuelle Zeit, dann erhalten wir die Wartezeit, wenn die Sperre fehlschlägt (es ist ein Zeitstempel) und dann erhalten wir die maximale Überlebenszeit der Sperre. Der Schlüssel von Redis verwendet hier dieses Format: „Sperre: Identifikationsname der Sperre“. Zuerst Daten in Redis einfügen und die Funktion setnx() verwenden Wenn der Schlüssel nicht vorhanden ist, fügen Sie die Daten ein und speichern Sie die maximale Überlebenszeit als Wert. Wenn das Einfügen erfolgreich ist, legen Sie die Ablaufzeit des Schlüssels fest und platzieren Sie den Schlüssel im Array $ lockedName. Geben Sie true zurück ; Wenn der Schlüssel vorhanden ist, wird der Einfügevorgang nicht ausgeführt. Dies bedeutet, dass die verbleibende Zeit kleiner als 0 ist Für den Schlüssel ist keine Überlebenszeit festgelegt (der Schlüssel existiert nicht), da setnx zuvor automatisch erstellt wurde. In diesem Fall stürzt eine bestimmte Instanz des Prozesses ab, nachdem setnx erfolgreich war, was dazu führt, dass der folgende Ablauf nicht aufgerufen wird . Zu diesem Zeitpunkt können Sie den Ablauf direkt festlegen und die Sperre für Ihren eigenen Gebrauch verwenden. Wenn die Wartezeit für den Sperrfehler nicht festgelegt ist oder die maximale Wartezeit überschritten wurde, verlassen Sie die Schleife. Andernfalls setzen Sie die Anforderung nach $waitIntervalUs fort. Dies ist die gesamte Codeanalyse des Sperrens.

/**
   * 加锁
   * @param [type] $name      锁的标识名
   * @param integer $timeout    循环获取锁的等待超时时间，在此时间内会一直尝试获取锁直到超时，为0表示失败后直接返回不等待
   * @param integer $expire     当前锁的最大生存时间(秒)，必须大于0，如果超过生存时间锁仍未被释放，则系统会自动强制释放
   * @param integer $waitIntervalUs 获取锁失败后挂起再试的时间间隔(微秒)
   * @return [type]         [description]
   */
  public function lock($name, $timeout = 0, $expire = 15, $waitIntervalUs = 100000) {
    if ($name == null) return false;

    //取得当前时间
    $now = time();
    //获取锁失败时的等待超时时刻
    $timeoutAt = $now + $timeout;
    //锁的最大生存时刻
    $expireAt = $now + $expire;

    $redisKey = "Lock:{$name}";
    while (true) {
      //将rediskey的最大生存时刻存到redis里，过了这个时刻该锁会被自动释放
      $result = $this->redisString->setnx($redisKey, $expireAt);

      if ($result != false) {
        //设置key的失效时间
        $this->redisString->expire($redisKey, $expireAt);
        //将锁标志放到lockedNames数组里
        $this->lockedNames[$name] = $expireAt;
        return true;
      }

      //以秒为单位，返回给定key的剩余生存时间
      $ttl = $this->redisString->ttl($redisKey);

      //ttl小于0 表示key上没有设置生存时间（key是不会不存在的，因为前面setnx会自动创建）
      //如果出现这种状况，那就是进程的某个实例setnx成功后 crash 导致紧跟着的expire没有被调用
      //这时可以直接设置expire并把锁纳为己用
      if ($ttl < 0) {
        $this->redisString->set($redisKey, $expireAt);
        $this->lockedNames[$name] = $expireAt;
        return true;
      }

      /*****循环请求锁部分*****/
      //如果没设置锁失败的等待时间 或者 已超过最大等待时间了，那就退出
      if ($timeout <= 0 || $timeoutAt < microtime(true)) break;

      //隔 $waitIntervalUs 后继续 请求
      usleep($waitIntervalUs);

    }

    return false;
  }

Schauen Sie sich dann die Code-Analyse des Entsperrens an: Der eingehende Parameter ist die Sperrkennung. Stellen Sie zunächst fest, ob die Sperre vorhanden ist, und löschen Sie sie aus redis ()-Funktion. Sperren Sie einfach das Logo.

/**
   * 解锁
   * @param [type] $name [description]
   * @return [type]    [description]
   */
  public function unlock($name) {
    //先判断是否存在此锁
    if ($this->isLocking($name)) {
      //删除锁
      if ($this->redisString->deleteKey("Lock:$name")) {
        //清掉lockedNames里的锁标志
        unset($this->lockedNames[$name]);
        return true;
      }
    }
    return false;
  }
　　　　在贴上删除掉所有锁的方法，其实都一个样，多了个循环遍历而已。
/**
   * 释放当前所有获得的锁
   * @return [type] [description]
   */
  public function unlockAll() {
    //此标志是用来标志是否释放所有锁成功
    $allSuccess = true;
    foreach ($this->lockedNames as $name => $expireAt) {
      if (false === $this->unlock($name)) {
        $allSuccess = false;  
      }
    }
    return $allSuccess;
  }

Das Obige ist eine Zusammenfassung und Weitergabe der gesamten Ideen und Code-Implementierung verteilter Sperren mit Redis. Hier füge ich den Code einer Implementierungsklasse hinzu. Im Code führe ich grundsätzlich eine Anmerkung durch werden bereitgestellt, damit jeder die Anwendung schnell verstehen und simulieren kann. Wenn Sie mehr darüber erfahren möchten, sehen Sie sich bitte den Code der gesamten Klasse an:

/**
 *在redis上实现分布式锁
 */
class RedisLock {
  private $redisString;
  private $lockedNames = [];

  public function construct($param = NULL) {
    $this->redisString = RedisFactory::get($param)->string;
  }

  /**
   * 加锁
   * @param [type] $name      锁的标识名
   * @param integer $timeout    循环获取锁的等待超时时间，在此时间内会一直尝试获取锁直到超时，为0表示失败后直接返回不等待
   * @param integer $expire     当前锁的最大生存时间(秒)，必须大于0，如果超过生存时间锁仍未被释放，则系统会自动强制释放
   * @param integer $waitIntervalUs 获取锁失败后挂起再试的时间间隔(微秒)
   * @return [type]         [description]
   */
  public function lock($name, $timeout = 0, $expire = 15, $waitIntervalUs = 100000) {
    if ($name == null) return false;

    //取得当前时间
    $now = time();
    //获取锁失败时的等待超时时刻
    $timeoutAt = $now + $timeout;
    //锁的最大生存时刻
    $expireAt = $now + $expire;

    $redisKey = "Lock:{$name}";
    while (true) {
      //将rediskey的最大生存时刻存到redis里，过了这个时刻该锁会被自动释放
      $result = $this->redisString->setnx($redisKey, $expireAt);

      if ($result != false) {
        //设置key的失效时间
        $this->redisString->expire($redisKey, $expireAt);
        //将锁标志放到lockedNames数组里
        $this->lockedNames[$name] = $expireAt;
        return true;
      }

      //以秒为单位，返回给定key的剩余生存时间
      $ttl = $this->redisString->ttl($redisKey);

      //ttl小于0 表示key上没有设置生存时间（key是不会不存在的，因为前面setnx会自动创建）
      //如果出现这种状况，那就是进程的某个实例setnx成功后 crash 导致紧跟着的expire没有被调用
      //这时可以直接设置expire并把锁纳为己用
      if ($ttl < 0) {
        $this->redisString->set($redisKey, $expireAt);
        $this->lockedNames[$name] = $expireAt;
        return true;
      }

      /*****循环请求锁部分*****/
      //如果没设置锁失败的等待时间 或者 已超过最大等待时间了，那就退出
      if ($timeout <= 0 || $timeoutAt < microtime(true)) break;

      //隔 $waitIntervalUs 后继续 请求
      usleep($waitIntervalUs);

    }

    return false;
  }

  /**
   * 解锁
   * @param [type] $name [description]
   * @return [type]    [description]
   */
  public function unlock($name) {
    //先判断是否存在此锁
    if ($this->isLocking($name)) {
      //删除锁
      if ($this->redisString->deleteKey("Lock:$name")) {
        //清掉lockedNames里的锁标志
        unset($this->lockedNames[$name]);
        return true;
      }
    }
    return false;
  }

  /**
   * 释放当前所有获得的锁
   * @return [type] [description]
   */
  public function unlockAll() {
    //此标志是用来标志是否释放所有锁成功
    $allSuccess = true;
    foreach ($this->lockedNames as $name => $expireAt) {
      if (false === $this->unlock($name)) {
        $allSuccess = false;  
      }
    }
    return $allSuccess;
  }

  /**
   * 给当前所增加指定生存时间，必须大于0
   * @param [type] $name [description]
   * @return [type]    [description]
   */
  public function expire($name, $expire) {
    //先判断是否存在该锁
    if ($this->isLocking($name)) {
      //所指定的生存时间必须大于0
      $expire = max($expire, 1);
      //增加锁生存时间
      if ($this->redisString->expire("Lock:$name", $expire)) {
        return true;
      }
    }
    return false;
  }

  /**
   * 判断当前是否拥有指定名字的所
   * @param [type] $name [description]
   * @return boolean    [description]
   */
  public function isLocking($name) {
    //先看lonkedName[$name]是否存在该锁标志名
    if (isset($this->lockedNames[$name])) {
      //从redis返回该锁的生存时间
      return (string)$this->lockedNames[$name] = (string)$this->redisString->get("Lock:$name");
    }

    return false;
  }

}

(2) Codeanalyse der Verwendung von Redis zur Implementierung der Aufgabenwarteschlange

(1) Aufgabenwarteschlange, die verwendet wird, um Vorgänge, die in der Geschäftslogik asynchron verarbeitet werden können, in die Warteschlange zu stellen und sie dann nach der Verarbeitung in anderen Threads aus der Warteschlange zu entfernen

(2) Verteilte Sperren und In der Warteschlange wird eine andere Logik verwendet. Stellen Sie die Konsistenz zwischen dem Beitritt und dem Verlassen des Teams sicher

（3）这个队列和普通队列不一样，入队时的id是用来区分重复入队的，队列里面只会有一条记录，同一个id后入的覆盖前入的，而不是追加， 如果需求要求重复入队当做不用的任务，请使用不同的id区分

　　先看入队的代码分析：首先当然是对参数的合法性检测，接着就用到上面加锁机制的内容了，就是开始加锁，入队时我这里选择当前时间戳作为score，接着就是入队了，使用的是zset数据结构的add()方法，入队完成后，就对该任务解锁，即完成了一个入队的操作。

/**
   * 入队一个 Task
   * @param [type] $name     队列名称
   * @param [type] $id      任务id（或者其数组）
   * @param integer $timeout    入队超时时间(秒)
   * @param integer $afterInterval [description]
   * @return [type]         [description]
   */
  public function enqueue($name, $id, $timeout = 10, $afterInterval = 0) {
    //合法性检测
    if (empty($name) || empty($id) || $timeout <= 0) return false;

    //加锁
    if (!$this->_redis->lock->lock("Queue:{$name}", $timeout)) {
      Logger::get(&#39;queue&#39;)->error("enqueue faild becouse of lock failure: name = $name, id = $id");
      return false;
    }
    
    //入队时以当前时间戳作为 score
    $score = microtime(true) + $afterInterval;
    //入队
    foreach ((array)$id as $item) {
      //先判断下是否已经存在该id了
      if (false === $this->_redis->zset->getScore("Queue:$name", $item)) {
        $this->_redis->zset->add("Queue:$name", $score, $item);
      }
    }
    
    //解锁
    $this->_redis->lock->unlock("Queue:$name");

    return true;

  }

　　接着来看一下出队的代码分析：出队一个Task，需要指定它的$id 和 $score，如果$score与队列中的匹配则出队，否则认为该Task已被重新入队过，当前操作按失败处理。首先和对参数进行合法性检测，接着又用到加锁的功能了，然后及时出队了，先使用getScore()从Redis里获取到该id的score，然后将传入的$score和Redis里存储的score进行对比，如果两者相等就进行出队操作，也就是使用zset里的delete()方法删掉该任务id，最后当前就是解锁了。这就是出队的代码分析。

/**
   * 出队一个Task，需要指定$id 和 $score
   * 如果$score 与队列中的匹配则出队，否则认为该Task已被重新入队过，当前操作按失败处理
   * 
   * @param [type] $name  队列名称 
   * @param [type] $id   任务标识
   * @param [type] $score  任务对应score，从队列中获取任务时会返回一个score，只有$score和队列中的值匹配时Task才会被出队
   * @param integer $timeout 超时时间(秒)
   * @return [type]      Task是否成功，返回false可能是redis操作失败，也有可能是$score与队列中的值不匹配（这表示该Task自从获取到本地之后被其他线程入队过）
   */
  public function dequeue($name, $id, $score, $timeout = 10) {
    //合法性检测
    if (empty($name) || empty($id) || empty($score)) return false;
    
    //加锁
    if (!$this->_redis->lock->lock("Queue:$name", $timeout)) {
      Logger:get('queue')->error("dequeue faild becouse of lock lailure:name=$name, id = $id");
      return false;
    }
    
    //出队
    //先取出redis的score
    $serverScore = $this->_redis->zset->getScore("Queue:$name", $id);
    $result = false;
    //先判断传进来的score和redis的score是否是一样
    if ($serverScore == $score) {
      //删掉该$id
      $result = (float)$this->_redis->zset->delete("Queue:$name", $id);
      if ($result == false) {
        Logger::get('queue')->error("dequeue faild because of redis delete failure: name =$name, id = $id");
      }
    }
    //解锁
    $this->_redis->lock->unlock("Queue:$name");

    return $result;
  }

　　学过数据结构这门课的朋友都应该知道，队列操作还有弹出顶部某个值的方法等等，这里处理入队出队操作

/**
   * 获取队列顶部若干个Task 并将其出队
   * @param [type] $name  队列名称
   * @param integer $count  数量
   * @param integer $timeout 超时时间
   * @return [type]      返回数组[0=>['id'=> , 'score'=> ], 1=>['id'=> , 'score'=> ], 2=>['id'=> , 'score'=> ]]
   */
  public function pop($name, $count = 1, $timeout = 10) {
    //合法性检测
    if (empty($name) || $count <= 0) return []; 
    
    //加锁
    if (!$this->_redis->lock->lock("Queue:$name")) {
      Log::get(&#39;queue&#39;)->error("pop faild because of pop failure: name = $name, count = $count");
      return false;
    }
    
    //取出若干的Task
    $result = [];
    $array = $this->_redis->zset->getByScore("Queue:$name", false, microtime(true), true, false, [0, $count]);

    //将其放在$result数组里 并 删除掉redis对应的id
    foreach ($array as $id => $score) {
      $result[] = [&#39;id&#39;=>$id, &#39;score&#39;=>$score];
      $this->_redis->zset->delete("Queue:$name", $id);
    }

    //解锁
    $this->_redis->lock->unlock("Queue:$name");

    return $count == 1 ? (empty($result) ? false : $result[0]) : $result;
  }

　　以上就是用Redis实现任务队列的整一套思路和代码实现的总结和分享

/**
 * 任务队列
 * 
 */
class RedisQueue {
  private $_redis;

  public function construct($param = null) {
    $this->_redis = RedisFactory::get($param);
  }

  /**
   * 入队一个 Task
   * @param [type] $name     队列名称
   * @param [type] $id      任务id（或者其数组）
   * @param integer $timeout    入队超时时间(秒)
   * @param integer $afterInterval [description]
   * @return [type]         [description]
   */
  public function enqueue($name, $id, $timeout = 10, $afterInterval = 0) {
    //合法性检测
    if (empty($name) || empty($id) || $timeout <= 0) return false;

    //加锁
    if (!$this->_redis->lock->lock("Queue:{$name}", $timeout)) {
      Logger::get(&#39;queue&#39;)->error("enqueue faild becouse of lock failure: name = $name, id = $id");
      return false;
    }
    
    //入队时以当前时间戳作为 score
    $score = microtime(true) + $afterInterval;
    //入队
    foreach ((array)$id as $item) {
      //先判断下是否已经存在该id了
      if (false === $this->_redis->zset->getScore("Queue:$name", $item)) {
        $this->_redis->zset->add("Queue:$name", $score, $item);
      }
    }
    
    //解锁
    $this->_redis->lock->unlock("Queue:$name");

    return true;

  }

  /**
   * 出队一个Task，需要指定$id 和 $score
   * 如果$score 与队列中的匹配则出队，否则认为该Task已被重新入队过，当前操作按失败处理
   * 
   * @param [type] $name  队列名称 
   * @param [type] $id   任务标识
   * @param [type] $score  任务对应score，从队列中获取任务时会返回一个score，只有$score和队列中的值匹配时Task才会被出队
   * @param integer $timeout 超时时间(秒)
   * @return [type]      Task是否成功，返回false可能是redis操作失败，也有可能是$score与队列中的值不匹配（这表示该Task自从获取到本地之后被其他线程入队过）
   */
  public function dequeue($name, $id, $score, $timeout = 10) {
    //合法性检测
    if (empty($name) || empty($id) || empty($score)) return false;
    
    //加锁
    if (!$this->_redis->lock->lock("Queue:$name", $timeout)) {
      Logger:get(&#39;queue&#39;)->error("dequeue faild becouse of lock lailure:name=$name, id = $id");
      return false;
    }
    
    //出队
    //先取出redis的score
    $serverScore = $this->_redis->zset->getScore("Queue:$name", $id);
    $result = false;
    //先判断传进来的score和redis的score是否是一样
    if ($serverScore == $score) {
      //删掉该$id
      $result = (float)$this->_redis->zset->delete("Queue:$name", $id);
      if ($result == false) {
        Logger::get(&#39;queue&#39;)->error("dequeue faild because of redis delete failure: name =$name, id = $id");
      }
    }
    //解锁
    $this->_redis->lock->unlock("Queue:$name");

    return $result;
  }

  /**
   * 获取队列顶部若干个Task 并将其出队
   * @param [type] $name  队列名称
   * @param integer $count  数量
   * @param integer $timeout 超时时间
   * @return [type]      返回数组[0=>['id'=> , 'score'=> ], 1=>['id'=> , 'score'=> ], 2=>['id'=> , 'score'=> ]]
   */
  public function pop($name, $count = 1, $timeout = 10) {
    //合法性检测
    if (empty($name) || $count <= 0) return []; 
    
    //加锁
    if (!$this->_redis->lock->lock("Queue:$name")) {
      Logger::get('queue')->error("pop faild because of pop failure: name = $name, count = $count");
      return false;
    }
    
    //取出若干的Task
    $result = [];
    $array = $this->_redis->zset->getByScore("Queue:$name", false, microtime(true), true, false, [0, $count]);

    //将其放在$result数组里 并 删除掉redis对应的id
    foreach ($array as $id => $score) {
      $result[] = ['id'=>$id, 'score'=>$score];
      $this->_redis->zset->delete("Queue:$name", $id);
    }

    //解锁
    $this->_redis->lock->unlock("Queue:$name");

    return $count == 1 ? (empty($result) ? false : $result[0]) : $result;
  }

  /**
   * 获取队列顶部的若干个Task
   * @param [type] $name 队列名称
   * @param integer $count 数量
   * @return [type]     返回数组[0=>['id'=> , 'score'=> ], 1=>['id'=> , 'score'=> ], 2=>['id'=> , 'score'=> ]]
   */
  public function top($name, $count = 1) {
    //合法性检测
    if (empty($name) || $count < 1) return [];

    //取错若干个Task
    $result = [];
    $array = $this->_redis->zset->getByScore("Queue:$name", false, microtime(true), true, false, [0, $count]);
    
    //将Task存放在数组里
    foreach ($array as $id => $score) {
      $result[] = ['id'=>$id, 'score'=>$score];
    }

    //返回数组 
    return $count == 1 ? (empty($result) ? false : $result[0]) : $result;    
  }
}

　　到此，这两大块功能基本讲解完毕，对于任务队列，你可以写一个shell脚本，让服务器定时运行某些程序，实现入队出队等操作，这里我就不在将其与实际应用结合起来去实现了，大家理解好这两大功能的实现思路即可，由于代码用的是PHP语言来写的，如果你理解了实现思路，你完全可以使用java或者是.net等等其他语言去实现这两个功能。这两大功能的应用场景十分多，特别是秒杀，另一个就是春运抢火车票，这两个是最鲜明的例子了。当然还有很多地方用到，这里我不再一一列举。

附上分布式锁和任务队列这两个类：

/**
 *在redis上实现分布式锁
 */
class RedisLock {
  private $redisString;
  private $lockedNames = [];

  public function construct($param = NULL) {
    $this->redisString = RedisFactory::get($param)->string;
  }

  /**
   * 加锁
   * @param [type] $name      锁的标识名
   * @param integer $timeout    循环获取锁的等待超时时间，在此时间内会一直尝试获取锁直到超时，为0表示失败后直接返回不等待
   * @param integer $expire     当前锁的最大生存时间(秒)，必须大于0，如果超过生存时间锁仍未被释放，则系统会自动强制释放
   * @param integer $waitIntervalUs 获取锁失败后挂起再试的时间间隔(微秒)
   * @return [type]         [description]
   */
  public function lock($name, $timeout = 0, $expire = 15, $waitIntervalUs = 100000) {
    if ($name == null) return false;

    //取得当前时间
    $now = time();
    //获取锁失败时的等待超时时刻
    $timeoutAt = $now + $timeout;
    //锁的最大生存时刻
    $expireAt = $now + $expire;

    $redisKey = "Lock:{$name}";
    while (true) {
      //将rediskey的最大生存时刻存到redis里，过了这个时刻该锁会被自动释放
      $result = $this->redisString->setnx($redisKey, $expireAt);

      if ($result != false) {
        //设置key的失效时间
        $this->redisString->expire($redisKey, $expireAt);
        //将锁标志放到lockedNames数组里
        $this->lockedNames[$name] = $expireAt;
        return true;
      }

      //以秒为单位，返回给定key的剩余生存时间
      $ttl = $this->redisString->ttl($redisKey);

      //ttl小于0 表示key上没有设置生存时间（key是不会不存在的，因为前面setnx会自动创建）
      //如果出现这种状况，那就是进程的某个实例setnx成功后 crash 导致紧跟着的expire没有被调用
      //这时可以直接设置expire并把锁纳为己用
      if ($ttl < 0) {
        $this->redisString->set($redisKey, $expireAt);
        $this->lockedNames[$name] = $expireAt;
        return true;
      }

      /*****循环请求锁部分*****/
      //如果没设置锁失败的等待时间 或者 已超过最大等待时间了，那就退出
      if ($timeout <= 0 || $timeoutAt < microtime(true)) break;

      //隔 $waitIntervalUs 后继续 请求
      usleep($waitIntervalUs);

    }

    return false;
  }

  /**
   * 解锁
   * @param [type] $name [description]
   * @return [type]    [description]
   */
  public function unlock($name) {
    //先判断是否存在此锁
    if ($this->isLocking($name)) {
      //删除锁
      if ($this->redisString->deleteKey("Lock:$name")) {
        //清掉lockedNames里的锁标志
        unset($this->lockedNames[$name]);
        return true;
      }
    }
    return false;
  }

  /**
   * 释放当前所有获得的锁
   * @return [type] [description]
   */
  public function unlockAll() {
    //此标志是用来标志是否释放所有锁成功
    $allSuccess = true;
    foreach ($this->lockedNames as $name => $expireAt) {
      if (false === $this->unlock($name)) {
        $allSuccess = false;  
      }
    }
    return $allSuccess;
  }

  /**
   * 给当前所增加指定生存时间，必须大于0
   * @param [type] $name [description]
   * @return [type]    [description]
   */
  public function expire($name, $expire) {
    //先判断是否存在该锁
    if ($this->isLocking($name)) {
      //所指定的生存时间必须大于0
      $expire = max($expire, 1);
      //增加锁生存时间
      if ($this->redisString->expire("Lock:$name", $expire)) {
        return true;
      }
    }
    return false;
  }

  /**
   * 判断当前是否拥有指定名字的所
   * @param [type] $name [description]
   * @return boolean    [description]
   */
  public function isLocking($name) {
    //先看lonkedName[$name]是否存在该锁标志名
    if (isset($this->lockedNames[$name])) {
      //从redis返回该锁的生存时间
      return (string)$this->lockedNames[$name] = (string)$this->redisString->get("Lock:$name");
    }

    return false;
  }

}

/**
 * 任务队列
 */
class RedisQueue {
  private $_redis;

  public function construct($param = null) {
    $this->_redis = RedisFactory::get($param);
  }

  /**
   * 入队一个 Task
   * @param [type] $name     队列名称
   * @param [type] $id      任务id（或者其数组）
   * @param integer $timeout    入队超时时间(秒)
   * @param integer $afterInterval [description]
   * @return [type]         [description]
   */
  public function enqueue($name, $id, $timeout = 10, $afterInterval = 0) {
    //合法性检测
    if (empty($name) || empty($id) || $timeout <= 0) return false;

    //加锁
    if (!$this->_redis->lock->lock("Queue:{$name}", $timeout)) {
      Logger::get(&#39;queue&#39;)->error("enqueue faild becouse of lock failure: name = $name, id = $id");
      return false;
    }
    
    //入队时以当前时间戳作为 score
    $score = microtime(true) + $afterInterval;
    //入队
    foreach ((array)$id as $item) {
      //先判断下是否已经存在该id了
      if (false === $this->_redis->zset->getScore("Queue:$name", $item)) {
        $this->_redis->zset->add("Queue:$name", $score, $item);
      }
    }
    
    //解锁
    $this->_redis->lock->unlock("Queue:$name");

    return true;

  }

  /**
   * 出队一个Task，需要指定$id 和 $score
   * 如果$score 与队列中的匹配则出队，否则认为该Task已被重新入队过，当前操作按失败处理
   * 
   * @param [type] $name  队列名称 
   * @param [type] $id   任务标识
   * @param [type] $score  任务对应score，从队列中获取任务时会返回一个score，只有$score和队列中的值匹配时Task才会被出队
   * @param integer $timeout 超时时间(秒)
   * @return [type]      Task是否成功，返回false可能是redis操作失败，也有可能是$score与队列中的值不匹配（这表示该Task自从获取到本地之后被其他线程入队过）
   */
  public function dequeue($name, $id, $score, $timeout = 10) {
    //合法性检测
    if (empty($name) || empty($id) || empty($score)) return false;
    
    //加锁
    if (!$this->_redis->lock->lock("Queue:$name", $timeout)) {
      Logger:get(&#39;queue&#39;)->error("dequeue faild becouse of lock lailure:name=$name, id = $id");
      return false;
    }
    
    //出队
    //先取出redis的score
    $serverScore = $this->_redis->zset->getScore("Queue:$name", $id);
    $result = false;
    //先判断传进来的score和redis的score是否是一样
    if ($serverScore == $score) {
      //删掉该$id
      $result = (float)$this->_redis->zset->delete("Queue:$name", $id);
      if ($result == false) {
        Logger::get(&#39;queue&#39;)->error("dequeue faild because of redis delete failure: name =$name, id = $id");
      }
    }
    //解锁
    $this->_redis->lock->unlock("Queue:$name");

    return $result;
  }

  /**
   * 获取队列顶部若干个Task 并将其出队
   * @param [type] $name  队列名称
   * @param integer $count  数量
   * @param integer $timeout 超时时间
   * @return [type]      返回数组[0=>['id'=> , 'score'=> ], 1=>['id'=> , 'score'=> ], 2=>['id'=> , 'score'=> ]]
   */
  public function pop($name, $count = 1, $timeout = 10) {
    //合法性检测
    if (empty($name) || $count <= 0) return []; 
    
    //加锁
    if (!$this->_redis->lock->lock("Queue:$name")) {
      Logger::get('queue')->error("pop faild because of pop failure: name = $name, count = $count");
      return false;
    }
    
    //取出若干的Task
    $result = [];
    $array = $this->_redis->zset->getByScore("Queue:$name", false, microtime(true), true, false, [0, $count]);

    //将其放在$result数组里 并 删除掉redis对应的id
    foreach ($array as $id => $score) {
      $result[] = ['id'=>$id, 'score'=>$score];
      $this->_redis->zset->delete("Queue:$name", $id);
    }

    //解锁
    $this->_redis->lock->unlock("Queue:$name");

    return $count == 1 ? (empty($result) ? false : $result[0]) : $result;
  }

  /**
   * 获取队列顶部的若干个Task
   * @param [type] $name 队列名称
   * @param integer $count 数量
   * @return [type]     返回数组[0=>['id'=> , 'score'=> ], 1=>['id'=> , 'score'=> ], 2=>['id'=> , 'score'=> ]]
   */
  public function top($name, $count = 1) {
    //合法性检测
    if (empty($name) || $count < 1) return [];

    //取错若干个Task
    $result = [];
    $array = $this->_redis->zset->getByScore("Queue:$name", false, microtime(true), true, false, [0, $count]);
    
    //将Task存放在数组里
    foreach ($array as $id => $score) {
      $result[] = ['id'=>$id, 'score'=>$score];
    }

    //返回数组 
    return $count == 1 ? (empty($result) ? false : $result[0]) : $result;    
  }
}

Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung der Codebeispiele für verteilte PHP-Redis-Sperren und Aufgabenwarteschlangen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!