首頁  >  文章  >  後端開發  >  php redis分散式鎖定和任務佇列程式碼實例詳解

php redis分散式鎖定和任務佇列程式碼實例詳解

伊谢尔伦
伊谢尔伦原創
2017-07-17 09:42:592472瀏覽

1.Redis實作分散式鎖定思路

  思路很簡單,主要用到的redis函式是setnx(),這應該是實作分散式鎖最主要的函數。首先是將某一任務識別名(這裡用Lock:order當識別名的例子)當作鍵存到redis裡,並為其設個過期時間,如果是還有Lock:order請求過來,先是透過setnx()看看是否能將Lock:order插入到redis裡,可以的話就回傳true,不可以就回傳false。當然,在我的程式碼裡會比這個想法複雜一些,我會在分析程式碼時進一步說明。

2.Redis實作任務佇列

  這裡的實作會用到上面的Redis分散式的鎖定機制,主要是用到了Redis裡的有序集合這一資料結構。例如入隊時,透過zset的add()函數進行入隊,而出對時,可以用到zset的getScore()函數。另外還可以彈出頂部的幾個任務。

3. 程式碼分析

(一)先分析Redis分散式鎖定的程式碼實作

##(1)為避免特殊原因導致鎖無法釋放,在加鎖成功後,鎖會被賦予一個生存時間(透過lock方法的參數設定或使用預設值),超出生存時間鎖會被自動釋放鎖的生存時間預設比較短(秒級),因此,若需要長時間加鎖,可以透過expire方法延長鎖的生存時間為適當時間,例如在循環內。

(2)系統層級的鎖當進程無論何種原因時出現crash時,作業系統會自行回收鎖,所以不會出現資源遺失,但分散式鎖不用,若一次設定很長時間,一旦因各種原因出現進程crash 或其他異常導致unlock未被呼叫時,則該鎖在剩餘的時間就會變成垃圾鎖,導致其他進程或進程重新啟動後無法進入加鎖區域。

先看加鎖的實作程式碼:這裡需要主要兩個參數,一個是$timeout,這個是循環取得鎖的等待時間,在這個時間內會一直嘗試取得鎖知道超時,如果為0 ,則表示獲取鎖失敗後直接返回而不再等待;另一個重要參數的$expire,這個參數指當前鎖的最大生存時間,以秒為單位的,它必須大於0,如果超過生存時間鎖仍未被釋放,則系統會自動強制釋放。這個參數的最要作用請看上面的(1)裡的解釋。

  這裡先取得當前時間,然後再獲取到鎖失敗時的等待超時的時刻(是個時間戳),再獲取到鎖的最大生存時刻是多少。這裡redis的key用這種格式:"Lock:鎖的識別名",這裡就開始進入循環了,先是插入資料到redis裡,使用setnx()函數,這函數的意思是,如果該鍵不存在則插入數據,將最大生存時刻作為值存儲,假如插入成功,則對該鍵進行失效時間的設置,並將該鍵放在$lockedName數組裡,返回true,也就是上鎖成功;如果該鍵存在,則不會插入操作了,這裡有一步嚴謹的操作,那就是取得當前鍵的剩餘時間,假如這個時間小於0,表示key上沒有設定生存時間(key是不會不存在的,因為前面setnx會自動創建)如果出現這種狀況,那就是進程的某個實例setnx成功後crash 導致緊跟著的expire沒有被調用,這時可以直接設置expire並把鎖納為己用。如果沒設定鎖定失敗的等待時間 或 已超過最大等待時間了,那就退出循環,反之則 隔 $waitIntervalUs 後繼續 請求。  這是整一個加鎖的程式碼分析。

/**
   * 加锁
   * @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;
  }

  接著看解鎖的代碼分析:解鎖就簡單多了,傳入參數就是鎖標識,先是判斷是否存在該鎖,存在的話,就從redis裡面透過deleteKey()函數刪除掉鎖標識即可。

/**
   * 解锁
   * @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;
  }

  以上就是用Redis實現分散式鎖的整一套思路和程式碼實現的總結和分享,這裡我附上正一個實現類的程式碼,程式碼裡我基本上對每一行進行了註釋,方便大家快速看懂並且能模擬應用。想要深入了解的請看整個類別的程式碼:

/**
 *在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;
  }

}

(二)用Redis實作任務佇列的程式碼分析

##(1 )任務佇列,用於將業務邏輯中可以非同步處理的操作放入佇列中,在其他執行緒中處理後出隊

(2)佇列中使用了分散式鎖定和其他邏輯,保證入隊和出隊的一致性

(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(&#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=>[&#39;id&#39;=> , &#39;score&#39;=> ], 1=>[&#39;id&#39;=> , &#39;score&#39;=> ], 2=>[&#39;id&#39;=> , &#39;score&#39;=> ]]
   */
  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;    
  }
}

以上是php redis分散式鎖定和任務佇列程式碼實例詳解的詳細內容。更多資訊請關注PHP中文網其他相關文章!

陳述:
本文內容由網友自願投稿,版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容,請聯絡admin@php.cn