Zookeeper实现分布式可重入锁，思路+代码，全程React
前言
某大佬讲完Zookeeper实现分布式锁以后，手一直很痒，所以自己动手实现了一遍(十遍...)... 废话不多说，开始
看这篇文章的话最好已经了解了zookeeper的使用和java api，以及React编程风格
WWW
what? 什么是分布式锁？我们平时写代码，如果遇到多个线程访问同一个互斥资源的时候，就需要加锁来保证安全。而在分布式技术大行其道的今天，就必须有人能够保证分布式环境下竞争同一个互斥资源的安全，这就是分布式锁。
why？为什么要用zk来做分布式锁？目前分布式锁的实现方案主要有数据库实现、Redis实现、ZK实现。ZK应该说是均衡的实现。至于为什么，欢迎移步各大论坛上的“分布式锁看这一篇就够了”博文，看我这一篇真的不够！
how？怎么用zk实现分布式锁？接下来的所有内容就围绕这一点来展开
分布式锁的条件
1、如果有人争抢锁，那么只能有一个人获得锁
2、如果获得锁的人挂掉了，不能导致死锁
3、获得锁的人要能够释放锁
4、锁被释放别的竞争者一定要知道
Zookeeper实现分布式锁思路
创建一个节点，所有想要获得锁的人都去这个节点下尝试创建一个子节点，这是一个
临时的有序节点(EPHEMERAL_SEQUENTIAL) 划重点 要考的
这里假设你已经知道什么是EPHEMERAL_SEQUENTIAL节点
我们只需要让所有争抢者中节点号最小的那个人拿到锁就可以了。其他人则没有得到锁。
由于zk中任何事件只要被集群接受就保证其一致性（最终），所以我们就解决了第一个问题：如果有人争抢锁，那么只能有一个人获得锁
第一个问题解决了。
由于zookeeper有会话机制，一旦持有锁的人挂掉，临时节点会被立即删除。所以很轻松地解决了第二个问题：如果获得锁的人挂掉了，不能导致死锁
第二个问题解决了。
只要获得锁的人执行完他要做的事，删掉自己创建的临时节点，锁就被释放了...所以第三个问题也解决了：获得锁的人要能够释放锁
第三个问题解决了。
相信你知道zookeeper的watch机制。试想一下，如果每一个人创建完节点之后，盯住他前面的节点...... 当前面的节点被删除，他就可以得到通知，于是他就可以继续判断自己是不是第一个人，如果是的话他就获得了锁，如果不是他就再往前盯一个......为什么不盯住所有的节点呢，因为这样会带来没必要的压力和延迟。
第四个问题解决了。
接下来我们来实现它
首先准备一个测试类
package com.join.zookeeper2.util;
public class DistributeLock{
/**
* 加锁方法
*/
public void lock(){
//@TODO 实现加锁
}
/**
* 解锁方法
*/
public void unlock(){
//@TODO 实现解锁
}
}
然后准备一个测试类
package com.join.zookeeper2;
import org.junit.Test;
import java.util.concurrent.TimeUnit;
public class TestLock {
@Test
public void testLock(){
//模拟十个人去抢锁
Thread[] threads = new Thread[10];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(()->{
//加锁
//业务逻辑
//尝试加锁测试可重入
//解锁
//解锁
});
}
for (Thread t : threads) {
//启动线程
t.start();
}
//避免主线程提前结束
try {
TimeUnit.SECONDS.sleep(120);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}然后准备一个用来连接Zookeeper的工具类
package com.join.zookeeper2.util;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import java.io.IOException;
import java.util.concurrent.CountDownLatch;
public class ZKUtil {
private static ZooKeeper zooKeeper;
private static final CountDownLatch c = new CountDownLatch(1);
private static final String path = "192.168.27.66:2181,192.168.27.67:2181,192.168.27.68:2181/testLock";
//获取zk对象
public static ZooKeeper getZK(){
try {
zooKeeper = new ZooKeeper(path,1000,new DefaultWatch());
c.await();
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
return zooKeeper;
}
//关闭连接
public static void release(){
try {
zooKeeper.close();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//zk连接时的watcher
static class DefaultWatch implements Watcher{
@Override
public void process(WatchedEvent event) {
switch (event.getState()) {
case Unknown:
break;
case Disconnected:
break;
case NoSyncConnected:
break;
case SyncConnected:
c.countDown();
break;
case AuthFailed:
break;
case ConnectedReadOnly:
break;
case SaslAuthenticated:
break;
case Expired:
break;
case Closed:
break;
}
}
}
}
首先我们来开发加锁方法
ZooKeeper zooKeeper = ZKUtil.getZK();
String threadName;
String pathName;
Thread thread;
Integer reentrant = 0;
/**
* 加锁方法
*/
public void lock(){
//拿到当前业务线程相关信息 方便日后解锁、制作可重入锁等
threadName = Thread.currentThread().getName();
thread = Thread.currentThread();
//实现可重入锁(如果这里获得的data是这个线程自己加上去的，那就直接让他继续运行)
byte[] data = new byte[0];
try {
data = zooKeeper.getData("/", false, new Stat());
} catch (KeeperException | InterruptedException e) {
e.printStackTrace();
}
if (data.length != 0 && threadName.equals(new String(data))){
this.reentrant++;
return;
}
//如果不是他自己加上去的，我们创建一个临时有序节点，同时阻塞住业务线程。这里的this看不懂的请看文中说明
zooKeeper.create("/lock", threadName.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL,this,"lock");
LockSupport.park();
}注意到了枷锁方法最后使用了一个回调，而回调传了this，所以我们给这个类实现对应接口
至此我们的类名变成了，同时多了这样一个方法，所以我们的类变成了这样子
public class DistributeLock implements Watcher, AsyncCallback.StringCallback{
ZooKeeper zooKeeper = ZKUtil.getZK();
String threadName;
String pathName;
Thread thread;
Integer reentrant = 0;
/**
* 加锁方法
*/
public void lock(){
threadName = Thread.currentThread().getName();
thread = Thread.currentThread();
//实现可重入锁
byte[] data = new byte[0];
try {
data = zooKeeper.getData("/", false, new Stat());
} catch (KeeperException | InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadName +" <==> "+new String(data));
if (data.length != 0 && threadName.equals(new String(data))){
this.reentrant++;
return;
}
zooKeeper.create("/lock", threadName.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL,this,"lock");
LockSupport.park();
}
/**
* 解锁方法
*/
public void unlock(){}
@Override
public void processResult(int rc, String path, Object ctx, String name) {
//记录一下自己创建的节点，也就是自己拿到的序号
this.pathName = name;
zooKeeper.getChildren("/",false,this,"getChildren");
}
}这里又使用了一个回调，而这里的watch我们填的是false。为什么呢？因为获得孩子这件事我们只关心得到的孩子，不需要watch
于是我们继续给我们的this实现接口 Children2Callback
这时我们的类变成了这样
public class DistributeLock implements Watcher, AsyncCallback.StringCallback{
ZooKeeper zooKeeper = ZKUtil.getZK();
String threadName;
String pathName;
Thread thread;
Integer reentrant = 0;
/**
* 加锁方法
*/
public void lock(){
threadName = Thread.currentThread().getName();
thread = Thread.currentThread();
//实现可重入锁
byte[] data = new byte[0];
try {
data = zooKeeper.getData("/", false, new Stat());
} catch (KeeperException | InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadName +" <==> "+new String(data));
if (data.length != 0 && threadName.equals(new String(data))){
this.reentrant++;
return;
}
zooKeeper.create("/lock", threadName.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL,this,"lock");
LockSupport.park();
}
/**
* 解锁方法
*/
public void unlock(){}
/**
* 创建节点的回调
*/
@Override
public void processResult(int rc, String path, Object ctx, String name) {
//记录一下自己创建的节点，也就是自己拿到的序号
this.pathName = name;
zooKeeper.getChildren("/",false,this,"getChildren");
}
/**
* 获得根节点孩子的回调
*/
@Override
public void processResult(int rc, String path, Object ctx, List children, Stat stat) {
//排序并判断自己是不是序号最小的那个
Collections.sort(children);
int i = children.indexOf(pathName.substring(1));
if (i == 0){
//是的话允许执行同步代码块
try {
zooKeeper.setData("/", threadName.getBytes(),-1);
} catch (KeeperException | InterruptedException e) {
e.printStackTrace();
}
LockSupport.unpark(this.thread);
}else {
//否则watch住前一个节点
zooKeeper.exists("/"+children.get(i-1),this,this,"watchLast");
}
}
} 这里又是一个回调。为什么这里的watch不再是false了呢。因为我们watch时，有可能出现前面的节点已经挂掉，我们watch不到的情景，这是我们需要处理的。这里又传了两个this，所以我们接着实现接口：Watcher、AsyncCallback.StatCallback
这时我们的代码变成这样
public class DistributeLock implements Watcher, AsyncCallback.StringCallback{
ZooKeeper zooKeeper = ZKUtil.getZK();
String threadName;
String pathName;
Thread thread;
Integer reentrant = 0;
/**
* 加锁方法
*/
public void lock(){
threadName = Thread.currentThread().getName();
thread = Thread.currentThread();
//实现可重入锁
byte[] data = new byte[0];
try {
data = zooKeeper.getData("/", false, new Stat());
} catch (KeeperException | InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadName +" <==> "+new String(data));
if (data.length != 0 && threadName.equals(new String(data))){
this.reentrant++;
return;
}
zooKeeper.create("/lock", threadName.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL,this,"lock");
LockSupport.park();
}
/**
* 解锁方法
*/
public void unlock(){}
/**
* 创建节点的回调
*/
@Override
public void processResult(int rc, String path, Object ctx, String name) {
//记录一下自己创建的节点，也就是自己拿到的序号
this.pathName = name;
zooKeeper.getChildren("/",false,this,"getChildren");
}
/**
* 获得根节点孩子的回调
*/
@Override
public void processResult(int rc, String path, Object ctx, List children, Stat stat) {
//排序并判断自己是不是序号最小的那个
Collections.sort(children);
int i = children.indexOf(pathName.substring(1));
if (i == 0){
//是的话允许执行同步代码块
try {
zooKeeper.setData("/", threadName.getBytes(),-1);
} catch (KeeperException | InterruptedException e) {
e.printStackTrace();
}
LockSupport.unpark(this.thread);
}else {
//否则watch住前一个节点
zooKeeper.exists("/"+children.get(i-1),this,this,"watchLast");
}
}
@Override
public void processResult(int rc, String path, Object ctx, Stat stat) {
//如果自己没有watch到，说明上一个节点突然挂掉了。那就需要重新判断自己的位置
if (KeeperException.create(KeeperException.Code.NONODE).code().intValue() == rc){
zooKeeper.getChildren("/",false,this,"getChildren");
}
}
@Override
public void process(WatchedEvent event) {
switch (event.getType()) {
case None:
break;
case NodeCreated:
break;
case NodeDeleted:
//如果上一个节点被删除了需要重新判断自己在队列中的位置
zooKeeper.getChildren("/",false,this,"getChildren");
break;
case NodeDataChanged:
break;
case NodeChildrenChanged:
break;
case DataWatchRemoved:
break;
case ChildWatchRemoved:
break;
}
}
} 最后我们来补全解锁逻辑，相信看到这里你就明白上面的Integer是做什么的了...
public class DistributeLock implements Watcher, AsyncCallback.StringCallback{
ZooKeeper zooKeeper = ZKUtil.getZK();
String threadName;
String pathName;
Thread thread;
Integer reentrant = 0;
/**
* 加锁方法
*/
public void lock(){
threadName = Thread.currentThread().getName();
thread = Thread.currentThread();
//实现可重入锁
byte[] data = new byte[0];
try {
data = zooKeeper.getData("/", false, new Stat());
} catch (KeeperException | InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadName +" <==> "+new String(data));
if (data.length != 0 && threadName.equals(new String(data))){
this.reentrant++;
return;
}
zooKeeper.create("/lock", threadName.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL,this,"lock");
LockSupport.park();
}
/**
* 解锁方法
*/
public void unlock(){
//直到重入锁的最后一层才进行删除节点
if (reentrant != 0){
reentrant--;
return;
}
//真正删除zookeeper中的节点
try {
zooKeeper.delete(pathName,-1);
} catch (InterruptedException | KeeperException e) {
e.printStackTrace();
}
}
/**
* 创建节点的回调
*/
@Override
public void processResult(int rc, String path, Object ctx, String name) {
//记录一下自己创建的节点，也就是自己拿到的序号
this.pathName = name;
zooKeeper.getChildren("/",false,this,"getChildren");
}
/**
* 获得根节点孩子的回调
*/
@Override
public void processResult(int rc, String path, Object ctx, List children, Stat stat) {
//排序并判断自己是不是序号最小的那个
Collections.sort(children);
int i = children.indexOf(pathName.substring(1));
if (i == 0){
//是的话允许执行同步代码块
try {
zooKeeper.setData("/", threadName.getBytes(),-1);
} catch (KeeperException | InterruptedException e) {
e.printStackTrace();
}
LockSupport.unpark(this.thread);
}else {
//否则watch住前一个节点
zooKeeper.exists("/"+children.get(i-1),this,this,"watchLast");
}
}
@Override
public void processResult(int rc, String path, Object ctx, Stat stat) {
//如果自己没有watch到，说明上一个节点突然挂掉了。那就需要重新判断自己的位置
if (KeeperException.create(KeeperException.Code.NONODE).code().intValue() == rc){
zooKeeper.getChildren("/",false,this,"getChildren");
}
}
@Override
public void process(WatchedEvent event) {
switch (event.getType()) {
case None:
break;
case NodeCreated:
break;
case NodeDeleted:
//如果上一个节点被删除了需要重新判断自己在队列中的位置
zooKeeper.getChildren("/",false,this,"getChildren");
break;
case NodeDataChanged:
break;
case NodeChildrenChanged:
break;
case DataWatchRemoved:
break;
case ChildWatchRemoved:
break;
}
}
} 好了至此我们的分布式锁就实现完成了。去zookeeper上创建好/testLock节点，准备好我们的测试类。对了不要忘记每次测试完手动清除一下根节点上的信息... 现在是1:28 我的脑子已经快不转了... 实在不想考虑怎么解决要手动清一下根节点上data的问题了
测试类代码：
package com.join.zookeeper2;
import com.join.zookeeper2.util.DistributeLock;
import org.junit.Test;
import java.util.concurrent.TimeUnit;
public class TestLock {
@Test
public void testLock(){
//模拟十个人去抢锁
Thread[] threads = new Thread[10];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(()->{
DistributeLock distributeLock = new DistributeLock();
distributeLock.lock();
System.out.println(Thread.currentThread().getName() +" working...");
//模拟业务的暂停
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//重入锁的测试
distributeLock.lock();
System.out.println(Thread.currentThread().getName() +" working...");
distributeLock.unlock();
distributeLock.unlock();
});
}
for (Thread t : threads) {
t.start();
}
try {
TimeUnit.SECONDS.sleep(120);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
发一下测试结果：
贴个github地址，想要代码的可以去下载:
https://github.com/xiaoy990/zk-distributeLock.git
最后：周老师牛逼！！！好了！这个代码可能存在不完善的问题... 我尽力了... 有问题大家一起讨论吧... 欢迎留言，本人目前大三在校生，想找份大厂工作，有空继续更技术。Over！