php使用zookeeper实现分布式锁

最新推荐文章于 2023-12-21 16:39:33 发布

梅坞茶坊

最新推荐文章于 2023-12-21 16:39:33 发布

阅读量558

点赞数

分类专栏： php 服务器文章标签： java 数据库 redis

本文链接：https://blog.csdn.net/qq_32421489/article/details/129364074

版权

php 同时被 2 个专栏收录

106 篇文章 1 订阅

订阅专栏

服务器

88 篇文章 0 订阅

订阅专栏

介绍

一、zookeeper和redis实现分布式锁的对比
1、redis 分布式场景应用比较广泛，redis分布式锁，其实需要自己不断去尝试获取锁，比较消耗性能；zk分布式锁，获取不到锁，注册个监听器即可，不需要不断主动尝试获取锁，性能开销较小

2、如果是redis获取锁的那个客户端bug了或者挂了，那么只能等待超时时间之后才能释放锁；而zk的话，因为创建的是临时znode，只要客户端挂了，znode就没了，此时就自动释放锁。

二、zookeeper分布式锁原理
这个主要得益于ZooKeeper为我们保证了数据的强一致性。锁服务可以分为两类，一个是保持独占，另一个是控制时序。

1、保持独占，就是所有试图来获取这个锁的客户端，最终只有一个可以成功获得这把锁。通常的做法是把zk上的一个znode看作是一把锁，通过create znode的方式来实现。所有客户端都去创建 /mylock节点，最终成功创建的那个客户端也即拥有了这把锁。

2、控制时序，就是所有试图来获取这个锁的客户端，最终都会被安排执行，只是有个全局时序。做法和上面基本类似，只是这里 /mylock已经预先存在，客户端在它下面创建临时顺序节点。Zk的父节点（/mylock）维持一份sequence,保证子节点创建的时序性，从而也形成了每个客户端的全局时序。

三、zookeeper实现分布式锁的方式
（1）方式一：创建一个临时节点

在需要获取排他锁时，所有的客户端都会试图通过调用 create -e 接口，在/mylock节点下创建临时子节点/mylock/lock。 ZooKeeper会保证在所有的客户端中，最络只有一个客户端能够创建成功，那么就可以认为该客户端获取了锁。

同时，所有没有获取到锁的客户端就需要对 /mylock/lock 节点上注册一个Watcher监听，以便实时监听到lock节点的变更情况。如果节点被使用完删除了，zookeeper要向所有监听者发送通知，这会阻塞其他操作，并且会导致所有客户端来争抢锁，这种情况称为“羊群效应”，试想一下，如果监听者众多的话，会拖累性能。

（2）方式二：创建临时顺序节点

create -s -e /mylock/lock-data
1、每个试图加锁的客户端都会创建一个临时顺序节点 /mylock/lock-xxxxx，并且zk可以保证序号连续且唯一；

2、然后获取 /mylock/ 下的所有子节点，并按从小到大排序list；

3、判断最小节点是不是自己，如果是证明你就获取锁了，可以去处理业务逻辑了；

4、如果不是，获取到list中你的上一个节点名称(不一定是 -1 的那一个，因为此时它对应的客户端有可能主动放弃了)，对其实施监听操作 get /mylock/lock-xxxxx watch 如果get监听失败了，说明节点已经别清除了，重复 2,3 直到监听成功或者获取锁，如果监听成功，就在这里阻塞，等待通知；

5、如果通知过来了，重复 2,3,4 的步骤，直到获取锁，因为上一个节点被释放的原因并不一定是它得到锁-使用完-释放，有可能是客户端断开连接了；

6、锁用完后记得主动清除，不然要等到心跳检测的时候才会清除。

优点：具备高可用、可重入、阻塞锁特性，可解决失效死锁问题。

缺点：因为需要频繁的创建和删除节点，性能上不如Redis方式。

四、安装PHP的zookeeper扩展
虽然ZooKeeper是一个Java应用程序，但C也可以使用。所以安装PHP的扩展，则首先安装zookeeper的C扩展支持

1、安装Zookeeper C扩展支持
示例中使用的zookeeper3.4.12版本

cd /usr/local/zk3.4/src/c

#编译C扩展，由于zookeeper解压即可用，这里下载源码主要是了编译C扩展，为后面安装PHP的扩展用
./configure --prefix=/usr/local/zk3.4/
make
make install
2、安装php的zookeeper扩展
zookeeper的PHP扩展可以在pecl上下载，也可以在github上下载，但有人说pecl上有bug。

git clone https://github.com/php-zookeeper/php-zookeeper.git
cd php-zookeeper
/usr/local/php7.4/bin/phpize
./configure --with-libzookeeper-dir=/usr/local/zk3.4/ --with-php-config=/usr/local/php7.4/bin/php-config
make && make install

vim php.ini
extension=zookeeper
/etc/php-fpm restart
五、PHP+zookeeper实现分布式锁示例
<?php

/*
* zookeeper 类属性常量参考
* https://www.php.net/manual/zh/class.zookeeper.php#zookeeper.class.constants.perms
*/
class zkCli {
   protected static $zk;
   protected static $myNode;
   protected static $isNotifyed;
   protected static $root;

   public static function getZkInstance($conf, $root){
       try{

           if(isset(self::$zk)){
               return self::$zk;
           }

           $zk = new \Zookeeper($conf['host'] . ':' . $conf['port']);
           if(!$zk){
               throw new \Exception('connect zookeeper error');
           }

           self::$zk = $zk;
           self::$root = $root;

           return $zk;
       } catch (\ZookeeperException $e){
           die($e->getMessage());
       } catch (\Exception $e){
           die($e->getMessage());
       }
   }

   // 获取锁
   public static function tryGetDistributedLock($lockKey, $value){
       try{
           // 创建根节点
           self::createRootPath($value);
           // 创建临时顺序节点
           self::createSubPath(self::$root . $lockKey, $value);
           // 获取锁
           return self::getLock();

       } catch (\ZookeeperException $e){
           return false;
       } catch (\Exception $e){
           return false;
       }
   }

   // 释放锁
   public static function releaseDistributedLock(){
       if(self::$zk->delete(self::$myNode)){
           return true;
       }else{
           return false;
       }
   }

   public static function createRootPath($value){
       $aclArray = [
           [
'perms' => Zookeeper::PERM_ALL,
'scheme' => 'world',
'id' => 'anyone',
           ]
       ];

// 判断根节点是否存在
       if(false == self::$zk->exists(self::$root)){
           // 创建根节点
           $result = self::$zk->create(self::$root, $value, $aclArray);
           if(false == $result){
               throw new \Exception('create '.self::$root.' fail');
           }
       }

       return true;
   }

   public static function createSubPath($path, $value){
       // 全部权限
       $aclArray = [
           [
               'perms' => Zookeeper::PERM_ALL,
           'scheme' => 'world',
           'id' => 'anyone',
           ]
       ];
       /**
* flags :
* 0 和 null 永久节点，
* Zookeeper::EPHEMERAL临时，
* Zookeeper::SEQUENCE顺序，
* Zookeeper::EPHEMERAL | Zookeeper::SEQUENCE 临时顺序
*/
       self::$myNode = self::$zk->create($path, $value, $aclArray, Zookeeper::EPHEMERAL | Zookeeper::SEQUENCE);
       if(false == self::$myNode){
           throw new \Exception('create -s -e '.$path.' fail');
       }
       echo 'my node is ' . self::$myNode.'-----------'.PHP_EOL;

       return true;
   }

   public function getLock(){
       // 获取子节点列表从小到大，显然不可能为空，至少有一个节点
       $res = self::checkMyNodeOrBefore();
       if($res === true){
           return true;
       }else{
           self::$isNotifyed = false;// 初始化状态值
           // 考虑监听失败的情况：当我正要监听before之前，它被清除了，监听失败返回 false
           $result = self::$zk->get($res, [zkCli::class, 'watcher']);
           while(!$result){
               $res1 = self::checkMyNodeOrBefore();
               if($res1 === true){
                   return true;
               }else{
                   $result = self::$zk->get($res1, [zkCli::class, 'watcher']);
               }
           }

           // 阻塞，等待watcher被执行，watcher执行完回到这里
           while(!self::$isNotifyed){
               echo '.';
               usleep(500000); // 500ms
           }

           return true;
       }
   }

/**
* 通知回调处理
* @param $type 变化类型 Zookeeper::CREATED_EVENT, Zookeeper::DELETED_EVENT, Zookeeper::CHANGED_EVENT
* @param $state
* @param $key 监听的path
*/
   public static function watcher($type, $state, $key){
       echo PHP_EOL.$key.' notifyed ....'.PHP_EOL;
       self::$isNotifyed = true;
       self::getLock();
   }

   public static function checkMyNodeOrBefore(){
       $list = self::$zk->getChildren(self::$root);
       sort($list);
       $root = self::$root;
       array_walk($list, function(&$val) use ($root){
           $val = $root . '/' . $val;
       });

       if($list[0] == self::$myNode){
           echo 'get locak node '.self::$myNode.'....'.PHP_EOL;
           return true;
       }else{
           // 找到上一个节点
           $index = array_search(self::$myNode, $list);
           $before = $list[$index - 1];
           echo 'before node '.$before.'.........'.PHP_EOL;
           return $before;
       }
   }
}

function zkLock($resourceId){
   $conf = ['host'=>'127.0.0.1', 'port'=>2181];
   $root = '/lockKey_' . $resourceId;
   $lockKey = '/lock_';
   $value = 'a';

   $client = zkCli::getZkInstance($conf, $root);
   $re = zkCli::tryGetDistributedLock($lockKey, $value);

   if($re){
       echo 'get lock success'.PHP_EOL;
   }else{
       echo 'get lock fail'.PHP_EOL;
       return ;
   }

   try {

       doSomething();

   } catch(\Exception $e) {

       echo $e->getMessage() . PHP_EOL;

   } finally {

       $re = zkCli::releaseDistributedLock();
       if($re){
           echo 'release lock success'.PHP_EOL;
       }else{
           echo 'release lock fail'.PHP_EOL;
       }

       return ;
   }
}

function doSomething(){
   $n = rand(1, 20);
   switch($n){
       case 1:
           sleep(15);// 模拟超时
           break;
       case 2:
           throw new \Exception('system throw message...');// 模拟程序中止
           break;
       case 3:
           die('system crashed...');// 模拟程序崩溃
           break;
       default:
           sleep(13);// 正常处理过程
   }
}

// 执行
zkLock(0);