漯河住房和城乡建设委员会网站深圳优化排名公司
介绍
一、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);