实现分布式锁目前有三种流行方案,分别为基于数据库、Redis、Zookeeper的方案,其中前两种方案网络上有很多资料可以参考,本文不做展开。我们来看下使用Zookeeper如何实现分布式锁。
什么是Zookeeper?
Zookeeper(业界简称zk)是一种提供配置管理、分布式协同以及命名的中心化服务,这些提供的功能都是分布式系统中非常底层且必不可少的基本功能,但是如果自己实现这些功能而且要达到高吞吐、低延迟同时还要保持一致性和可用性,实际上非常困难。因此zookeeper提供了这些功能,开发者在zookeeper之上构建自己的各种分布式系统。
虽然zookeeper的实现比较复杂,但是它提供的模型抽象却是非常简单的。Zookeeper提供一个多层级的节点命名空间(节点称为znode),每个节点都用一个以斜杠(/)分隔的路径表示,而且每个节点都有父节点(根节点除外),非常类似于文件系统。例如,/foo/doo这个表示一个znode,它的父节点为/foo,父父节点为/,而/为根节点没有父节点。与文件系统不同的是,这些节点都可以设置关联的数据,而文件系统中只有文件节点可以存放数据而目录节点不行。Zookeeper为了保证高吞吐和低延迟,在内存中维护了这个树状的目录结构,这种特性使得Zookeeper不能用于存放大量的数据,每个节点的存放数据上限为1M。
而为了保证高可用,zookeeper需要以集群形态来部署,这样只要集群中大部分机器是可用的(能够容忍一定的机器故障),那么zookeeper本身仍然是可用的。客户端在使用zookeeper时,需要知道集群机器列表,通过与集群中的某一台机器建立TCP连接来使用服务,客户端使用这个TCP链接来发送请求、获取结果、获取监听事件以及发送心跳包。如果这个连接异常断开了,客户端可以连接到另外的机器上。
架构简图如下所示:
zookeeper
客户端的读请求可以被集群中的任意一台机器处理,如果读请求在节点上注册了监听器,这个监听器也是由所连接的zookeeper机器来处理。对于写请求,这些请求会同时发给其他zookeeper机器并且达成一致后,请求才会返回成功。因此,随着zookeeper的集群机器增多,读请求的吞吐会提高但是写请求的吞吐会下降。
有序性是zookeeper中非常重要的一个特性,所有的更新都是全局有序的,每个更新都有一个唯一的时间戳,这个时间戳称为zxid(Zookeeper Transaction Id)。而读请求只会相对于更新有序,也就是读请求的返回结果中会带有这个zookeeper最新的zxid。
如何使用zookeeper实现分布式锁?
在描述算法流程之前,先看下zookeeper中几个关于节点的有趣的性质:
-
有序节点:假如当前有一个父节点为/lock,我们可以在这个父节点下面创建子节点;zookeeper提供了一个可选的有序特性,例如我们可以创建子节点“/lock/node-”并且指明有序,那么zookeeper在生成子节点时会根据当前的子节点数量自动添加整数序号,也就是说如果是第一个创建的子节点,那么生成的子节点为/lock/node-0000000000,下一个节点则为/lock/node-0000000001,依次类推。
-
临时节点:客户端可以建立一个临时节点,在会话结束或者会话超时后,zookeeper会自动删除该节点。
-
事件监听:在读取数据时,我们可以同时对节点设置事件监听,当节点数据或结构变化时,zookeeper会通知客户端。当前zookeeper有如下四种事件:1)节点创建;2)节点删除;3)节点数据修改;4)子节点变更。
下面描述使用zookeeper实现分布式锁的算法流程,假设锁空间的根节点为/lock:
-
客户端连接zookeeper,并在/lock下创建临时的且有序的子节点,第一个客户端对应的子节点为/lock/lock-0000000000,第二个为/lock/lock-0000000001,以此类推。
-
客户端获取/lock下的子节点列表,判断自己创建的子节点是否为当前子节点列表中序号最小的子节点,如果是则认为获得锁,否则监听/lock的子节点变更消息,获得子节点变更通知后重复此步骤直至获得锁;
-
执行业务代码;
-
完成业务流程后,删除对应的子节点释放锁。
步骤1中创建的临时节点能够保证在故障的情况下锁也能被释放,考虑这么个场景:假如客户端a当前创建的子节点为序号最小的节点,获得锁之后客户端所在机器宕机了,客户端没有主动删除子节点;如果创建的是永久的节点,那么这个锁永远不会释放,导致死锁;由于创建的是临时节点,客户端宕机后,过了一定时间zookeeper没有收到客户端的心跳包判断会话失效,将临时节点删除从而释放锁。
另外细心的朋友可能会想到,在步骤2中获取子节点列表与设置监听这两步操作的原子性问题,考虑这么个场景:客户端a对应子节点为/lock/lock-0000000000,客户端b对应子节点为/lock/lock-0000000001,客户端b获取子节点列表时发现自己不是序号最小的,但是在设置监听器前客户端a完成业务流程删除了子节点/lock/lock-0000000000,客户端b设置的监听器岂不是丢失了这个事件从而导致永远等待了?这个问题不存在的。因为zookeeper提供的API中设置监听器的操作与读操作是原子执行的,也就是说在读子节点列表时同时设置监听器,保证不会丢失事件。
最后,对于这个算法有个极大的优化点:假如当前有1000个节点在等待锁,如果获得锁的客户端释放锁时,这1000个客户端都会被唤醒,这种情况称为“羊群效应”;在这种羊群效应中,zookeeper需要通知1000个客户端,这会阻塞其他的操作,最好的情况应该只唤醒新的最小节点对应的客户端。应该怎么做呢?在设置事件监听时,每个客户端应该对刚好在它之前的子节点设置事件监听,例如子节点列表为/lock/lock-0000000000、/lock/lock-0000000001、/lock/lock-0000000002,序号为1的客户端监听序号为0的子节点删除消息,序号为2的监听序号为1的子节点删除消息。
zookeeper学习中
所以调整后的分布式锁算法流程如下:
-
客户端连接zookeeper,并在/lock下创建临时的且有序的子节点,第一个客户端对应的子节点为/lock/lock-0000000000,第二个为/lock/lock-0000000001,以此类推;
-
客户端获取/lock下的子节点列表,判断自己创建的子节点是否为当前子节点列表中序号最小的子节点,如果是则认为获得锁,否则监听刚好在自己之前一位的子节点删除消息,获得子节点变更通知后重复此步骤直至获得锁;
-
执行业务代码;
-
完成业务流程后,删除对应的子节点释放锁。
下面用java原生api去实现分布式锁:
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.4.8</version>
<type>pom</type>
</dependency>
在集群中创建分布式锁的根节点:
[zk: localhost:2181(CONNECTED) 5] create /LOCKS 00
Created /LOCKS
[zk: localhost:2181(CONNECTED) 6] ls /
[LOCKS, zookeeper, event, linshi, pang]
/**
* 创建客户端会话
*/
public class ZookeeperClient {
private final static String CONNECTIONSTRING="127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183";
private static int sessionTimeout = 5000;
//获取连接
public static ZooKeeper getInstance() throws IOException, InterruptedException {
final CountDownLatch countDownLatch = new CountDownLatch(1);//利用这个wait方法保存已连接状态,有延时
ZooKeeper zooKeeper = new ZooKeeper(CONNECTIONSTRING, sessionTimeout, new Watcher() {
@Override
public void process(WatchedEvent event) {
if (event.getState() == Event.KeeperState.SyncConnected){//判断是否已经连接上
countDownLatch.countDown();
}
}
});
countDownLatch.await();
return zooKeeper;
}
public static int getSessionTimeout() {
return sessionTimeout;
}
}
/**
* 监听节点被删除事件
*/
public class LockWatcher implements Watcher{
private CountDownLatch latch;
public LockWatcher(CountDownLatch latch) {
this.latch = latch;
}
@Override
public void process(WatchedEvent event) {
if(event.getType()== Event.EventType.NodeDeleted){//判断是不是节点删除了
latch.countDown();
}
}
}
/**
* 分布式锁实现
*/
public class DistributeLock {
private static final String ROOT_LOCK="/LOCKS";//根节点
private ZooKeeper zooKeeper;
private int sessionTimeout;//会话超时时间
private String lockID;//记录锁节点ID
private final static byte[] data = {1,2};//节点数据
private CountDownLatch countDownLatch = new CountDownLatch(1);
public DistributeLock() throws IOException, InterruptedException {
this.zooKeeper = ZookeeperClient.getInstance();
this.sessionTimeout = ZookeeperClient.getSessionTimeout();
}
//获取锁的方法
public boolean lock(){
try {
//四个参数:路径、保存内容、权限、临时有序节点 LOCKS/0000000001
lockID = zooKeeper.create(ROOT_LOCK+"/",data, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
System.out.println(Thread.currentThread().getName()+"-->成功创建了lock节点,节点ID="+lockID+"开始去竞争锁");
//获取当前根节点下所有的节点,然后判断是不是最小节点
List<String> childrenNodes = zooKeeper.getChildren(ROOT_LOCK,true);
//排序从小到大
SortedSet<String> sortedSet = new TreeSet<String>();
for (String children : childrenNodes){
sortedSet.add(ROOT_LOCK+"/"+children);
}
String first = sortedSet.first();//拿到最小的节点
if (lockID.equals(first)){
//表示当前就是最小的节点
System.out.println(Thread.currentThread().getName()+"---->成功的获取锁.lock节点为="+lockID);
return true;
}
//拿到这个节点之前的所有节点,再拿最后一个节点,就是拿当前节点的上一个节点,用于监听变化
SortedSet<String> lessThanLockID = sortedSet.headSet(lockID);
if (!lessThanLockID.isEmpty()){
String prevLockID = lessThanLockID.last();
zooKeeper.exists(prevLockID,new LockWatcher(countDownLatch));
countDownLatch.await(sessionTimeout, TimeUnit.MILLISECONDS);
//上面这段代码意味着会话超时或者节点被删除(释放)了
System.out.println(Thread.currentThread().getName()+"成功获取锁,lockID="+lockID);
}
return true;
} catch (KeeperException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
return false;
}
//释放锁的方法
public boolean unlock(){
try {
System.out.println(Thread.currentThread().getName()+"--->开始释放锁lock="+lockID);
zooKeeper.delete(lockID,-1);
System.out.println("节点"+lockID+"成功被删除");
return true;
} catch (InterruptedException e) {
e.printStackTrace();
} catch (KeeperException e) {
e.printStackTrace();
}
return false;
}
public static void main(String[] args) {
final CountDownLatch latch = new CountDownLatch(10);
Random random = new Random();
for (int i=0 ;i < 10;i++){
new Thread(()->{
DistributeLock lock = null;
try {
lock = new DistributeLock();
latch.countDown();
latch.await();
lock.lock();
Thread.sleep(random.nextInt(500));
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
if (lock != null){
lock.unlock();
}
}
}).start();
}
}
}
输出结果:
Thread-3-->成功创建了lock节点,节点ID=/LOCKS/0000000060开始去竞争锁
Thread-0-->成功创建了lock节点,节点ID=/LOCKS/0000000061开始去竞争锁
Thread-8-->成功创建了lock节点,节点ID=/LOCKS/0000000065开始去竞争锁
Thread-9-->成功创建了lock节点,节点ID=/LOCKS/0000000062开始去竞争锁
Thread-7-->成功创建了lock节点,节点ID=/LOCKS/0000000063开始去竞争锁
Thread-5-->成功创建了lock节点,节点ID=/LOCKS/0000000066开始去竞争锁
Thread-2-->成功创建了lock节点,节点ID=/LOCKS/0000000067开始去竞争锁
Thread-6-->成功创建了lock节点,节点ID=/LOCKS/0000000069开始去竞争锁
Thread-1-->成功创建了lock节点,节点ID=/LOCKS/0000000068开始去竞争锁
Thread-3---->成功的获取锁.lock节点为=/LOCKS/0000000060
Thread-4-->成功创建了lock节点,节点ID=/LOCKS/0000000064开始去竞争锁
Thread-3--->开始释放锁lock=/LOCKS/0000000060
节点/LOCKS/0000000060成功被删除
Thread-0成功获取锁,lockID=/LOCKS/0000000061
Thread-0--->开始释放锁lock=/LOCKS/0000000061
节点/LOCKS/0000000061成功被删除
Thread-9成功获取锁,lockID=/LOCKS/0000000062
Thread-9--->开始释放锁lock=/LOCKS/0000000062
节点/LOCKS/0000000062成功被删除
Thread-7成功获取锁,lockID=/LOCKS/0000000063
Thread-7--->开始释放锁lock=/LOCKS/0000000063
节点/LOCKS/0000000063成功被删除
Thread-4成功获取锁,lockID=/LOCKS/0000000064
Thread-4--->开始释放锁lock=/LOCKS/0000000064
Thread-8成功获取锁,lockID=/LOCKS/0000000065
节点/LOCKS/0000000064成功被删除
Thread-8--->开始释放锁lock=/LOCKS/0000000065
Thread-5成功获取锁,lockID=/LOCKS/0000000066
节点/LOCKS/0000000065成功被删除
Thread-5--->开始释放锁lock=/LOCKS/0000000066
Thread-2成功获取锁,lockID=/LOCKS/0000000067
节点/LOCKS/0000000066成功被删除
Thread-2--->开始释放锁lock=/LOCKS/0000000067
节点/LOCKS/0000000067成功被删除
Thread-1成功获取锁,lockID=/LOCKS/0000000068
Thread-1--->开始释放锁lock=/LOCKS/0000000068
Thread-6成功获取锁,lockID=/LOCKS/0000000069
节点/LOCKS/0000000068成功被删除
Thread-6--->开始释放锁lock=/LOCKS/0000000069
节点/LOCKS/0000000069成功被删除
下面用java原生curator去实现分布式锁:
public class CuratorDistrLockTest {
/** Zookeeper info */
private final static String ZK_ADDRESS="127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183";
private static final String ZK_LOCK_PATH = "/zktest";
public static void main(String[] args) throws InterruptedException {
// 1.Connect to zk
CuratorFramework client = CuratorFrameworkFactory.newClient(
ZK_ADDRESS,
new RetryNTimes(10, 5000)
);
client.start();
System.out.println("zk client start successfully!");
Thread t1 = new Thread(() -> {
doWithLock(client);
}, "t1");
Thread t2 = new Thread(() -> {
doWithLock(client);
}, "t2");
Thread t3 = new Thread(() -> {
doWithLock(client);
}, "t3");
t1.start();
t2.start();
t3.start();
}
private static void doWithLock(CuratorFramework client) {
//Curator提供的InterProcessMutex是分布式锁的实现。通过acquire获得锁,并提供超时机制,release方法用于释放锁。
InterProcessMutex lock = new InterProcessMutex(client, ZK_LOCK_PATH);
try {
if (lock.acquire(10 * 1000, TimeUnit.SECONDS)) {
System.out.println(Thread.currentThread().getName() + " hold lock");
Thread.sleep(5000L);
System.out.println(Thread.currentThread().getName() + " release lock");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
lock.release();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
输出结果:
zk client start successfully!
t1 hold lock
t1 release lock
t2 hold lock
t2 release lock
t3 hold lock
t3 release lock