php实现分布式锁

1.锁实现的注意点

1. 互斥: 任意时刻, 只能有一个客户端获得锁
2. 不会死锁: 客户端持有锁期间崩溃, 没有主动解除锁, 能保证后续的其他客户端获得锁
3. 锁归属标识: 加锁和解锁的必须是同一个客户端, 客户端不能解掉非自己持有的锁(锁应具备标识

2.锁的几种错误类型 

1. Redis 锁错误使用之一

$redis = new Redis();
$redis->connect("127.0.0.1",6379);
$ret = $redis->setnx('lock',1);
if ($ret) {
    //do 业务逻辑
    $redis->del('lock');//删除锁
}

 这里有个问题，如果业务逻辑出现异常，或者因为某种原因导致无法删除key，那么会造成死锁

  2. Redis 锁错误使用之二

为了解决1的问题

$redis = new Redis();
$redis->connect("127.0.0.1",6379);
$ret = $redis->setnx('lock',1);
if ($ret) {
    $redis->expire('lock',5);
    //do 业务逻辑
    $redis->del('lock');
}

我们增加了过期时间解决了1中可能出现死锁的问题，我们都知道redis单条命令虽然是具备原子性的，但是多条命令一起使用就不是了，如果setnx 执行成功 expire执行失败，那么依然可能会在使用过程出现问题，为了解决2中出现的问题，我们适当增加部分代码

$redis = new Redis();
$redis->connect("127.0.0.1",6379);
$ret = $redis->setnx("lock",1);
if ($ret) {
    $redis->expire('lock',5);
} else {
    $expire = $redis->ttl('lock');
    if (!$expire) {
        $redis->expire('lock',5);
    }
}

图中加了ttl函数判断是否超时。如果超时就增加过期时间，这个方案比上一个更健壮，但是依然无法百分之百解决问题。不过redis在版本 2.6.12 开始为set 命令增加了一个过期时间选择，这样就保证了原子性。

$redis = new Redis();
$ret = $redis->set('lock',1,['nx', 'ex' => 10]);

虽然上面一步已经满足了我们的需求，但是还是要考虑其它问题 

1、 redis发现锁失败了要怎么办？中断请求还是循环请求？ 
2、 循环请求的话，如果有一个获取了锁，其它的在去获取锁的时候，是不是容易发生抢锁的可能？ 
3、 锁提前过期后，客户端A还没执行完，然后客户端B获取到了锁，这时候客户端A执行完了，会不会在删锁的时候把B的锁给删掉？

//针对问题1：使用循环请求，循环请求去获取锁
//针对问题2：针对第二个问题，在循环请求获取锁的时候，加入睡眠功能，等待几毫秒在执行循环
//针对问题3：在加锁的时候存入的key是随机的。这样的话，每次在删除key的时候判断下存入的key里的value和自己存的是否一样
class Lock
{
     public $redis = null;
     public $key   ="";
     public $timeOut = 0;
     public $lockOut = 0;
     public function __construct($key,$timeOut,$lockOut)
     {
         $this->redis = new Redis();
         $this->redis->connect("127.0.0.1",6379);
         $this->key   = $key;
         $this->timeOut = $timeOut;
         $this->lockOut = $lockOut;
     }
     public function addLock()
     {
          $time = time();
          $endTime = $time + $this->timeOut;
          $value = mt_rand(1000,10000);
          do {
              $isLock = $this->redis->set($this->key,$value,['nx','ex'=>$this->lockOut]);
              if ($isLock) {
                  return $value;
              } else {
                  usleep(5000);///睡眠，降低抢锁频率，缓解redis压力，针对问题2
              }
          } while(time()<$endTime);
          return false;
     }
     //无法保证原子性解锁
     public function releaseLock($value)
     {
           if ($this->redis->get($this->key)==$value) {
               $this->redis->del($this->key);
           }

     }
     //采用lua 脚本解锁
     public function releaseLock1($value)
     {
          $script=<<<EOT
          if redis.call("GET",KEYS[1]) == ARGV[1]
          then
              return redis.call("DEL",KEYS[1])
          else
              return 0
          end
EOT;
        return  $this->redis->eval($script,[$this->key,$value],1);
     }
     //利用redis watch 解锁
     public function releaseLock2($value)
     {
          $redis = $this->redis;
          $this->redis->multi($redis::PIPELINE);
          while(true) {
              try {
                  $redis->watch($this->key);
                  if ($redis->get($this->key)==$value) {
                      $redis->del($this->key);
                      $redis->exec();
                       return true;
                  } else {
                      $redis->unwatch($this->key);
                       break;
                  }
              } catch (Exception $e) {
                  echo $e->getMessage();
              }

          }
          return false;

     }
}

解锁的方法有3种，依然是多条命令非原子性问题，所以第二种，第三种解锁才更科学。

尽管上面的方法更健壮了，但是依然有些问题，如果上锁后业务逻辑执行时间过长超过了过期时间怎么办？如果你是 Java 技术栈，幸运的是，已经有一个库把这些工作都封装好了：Redisson，目前php没找到相关解决方案,只能根据经验判断业务逻辑执行时长并把过期时间设置稍微长一些

3.具体可以阅读知乎一位大神佳作

怎样实现redis分布式锁？