Zookeeper——分布式锁的概念理解 & 应用举例
Posted 宋子浩
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Zookeeper——分布式锁的概念理解 & 应用举例相关的知识，希望对你有一定的参考价值。
文章目录：
1.前言
什么叫做分布式锁呢？比如说"进程 1"在使用该资源的时候，会先去获得锁，"进程 1"获得锁以后会对该资源保持独占，这样其他进程就无法访问该资源，"进程 1"用完该资源以后就将锁释放掉，让其他进程来获得锁，那么通过这个锁机制，我们就能保证了分布式系统中多个进程能够有序的访问该临界资源。那么我们把这个分布式环境下的这个锁叫作分布式锁。
2.原生Zookeeper实现分布式锁
代码中的注释我已经写的很详细了。
这其中用到了JUC中的CountDownLatch，可以参考：https://blog.csdn.net/weixin_43823808/article/details/120799251
package com.szh.case2;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CountDownLatch;
/**
*
*/
public class DistributedZkLock
private final String connectString = "192.168.40.130:2181";
private final int sessionTimeout = 30000;
private final ZooKeeper zk;
private CountDownLatch connectLatch = new CountDownLatch(1);
private CountDownLatch waitLatch = new CountDownLatch(1);
private String currentNode;
private String waitPath;
public DistributedZkLock() throws IOException, InterruptedException, KeeperException
//获取zk连接
zk = new ZooKeeper(connectString, sessionTimeout, new Watcher()
@Override
public void process(WatchedEvent watchedEvent)
//如果连接上zk，则connectLatch可以释放
if (watchedEvent.getState() == Event.KeeperState.SyncConnected)
connectLatch.countDown();
//如果监听的节点已被删除，同时当前监听的节点路径与即将被监听节点的前一个节点路径相同，则waitLatch可以释放
if (watchedEvent.getType() == Event.EventType.NodeDeleted && watchedEvent.getPath().equals(waitPath))
waitLatch.countDown();
);
//等待zk连接成功之后，程序则继续往下走，其他线程进入等待连接的状态
connectLatch.await();
//判断根节点 /locks 是否存在
Stat stat = zk.exists("/locks", false);
//如果根节点 /locks 不存在，则立马创建
if (Objects.isNull(stat))
//此 /locks 节点默认所有人均可访问，而且是永久性节点
zk.create("/locks", "locks".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
//加锁
public void zkLock()
try
//所谓加锁，就是在根节点/locks下创建对应的临时、带序号的节点
currentNode = zk.create("/locks/" + "seq-", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
//睡一会，让结果更清晰
Thread.sleep(100);
//判断创建的节点是否是序号最小的节点，如果是，则获取到锁；如果不是，则监听它序号的前一个节点
List<String> children = zk.getChildren("/locks", false);
if (children.size() == 1) //只有一个节点，则直接获取锁
return;
else //如果有多个节点，则需要判断谁的序号最小
//先对获取的节点的list集合排序，确保从小到大的顺序
Collections.sort(children);
//获取节点名称 seq-00000000
String thisNode = currentNode.substring("/locks/".length());
//通过节点名称获取到它在list集合中的位置
int index = children.indexOf(thisNode);
if (index == -1) //没数据，无意义
System.out.println("数据异常....");
else if (index == 0) //说明此节点处于第一个位置，可以获取锁
return;
else //非第一个位置，需要监听前一个节点的变化
//获取该节点序号的前一个节点
waitPath = "/locks/" + children.get(index - 1);
//监听，回调Watch的process方法
zk.getData(waitPath, true, new Stat());
//其他线程进入等待锁的状态
waitLatch.await();
return;
catch (KeeperException e)
e.printStackTrace();
catch (InterruptedException e)
e.printStackTrace();
//解锁
public void zkUnLock()
//删除节点即解锁
try
zk.delete(this.currentNode, -1);
catch (InterruptedException e)
e.printStackTrace();
catch (KeeperException e)
e.printStackTrace();
下面是针对上面的一些方法的测试。
package com.szh.case2;
import org.apache.zookeeper.KeeperException;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
/**
*
*/
public class DistributedZkLockTest
public static void main(String[] args) throws InterruptedException, IOException, KeeperException
//创建分布式锁1
final DistributedZkLock lock1 = new DistributedZkLock();
//创建分布式锁2
final DistributedZkLock lock2 = new DistributedZkLock();
//如下创建两个线程，模拟获取分布式锁的过程
new Thread(new Runnable()
@Override
public void run()
try
lock1.zkLock();
System.out.println(Thread.currentThread().getName() + " 已启动，获取到锁....");
TimeUnit.MILLISECONDS.sleep(3000);
lock1.zkUnLock();
System.out.println(Thread.currentThread().getName() + "已释放锁....");
catch (InterruptedException e)
e.printStackTrace();
).start();
new Thread(new Runnable()
@Override
public void run()
try
lock2.zkLock();
System.out.println(Thread.currentThread().getName() + " 已启动，获取到锁....");
TimeUnit.MILLISECONDS.sleep(3000);
lock2.zkUnLock();
System.out.println(Thread.currentThread().getName() + "已释放锁....");
catch (InterruptedException e)
e.printStackTrace();
).start();
那么上面是我们自己手写的加锁、解锁的一些方法，其中也存在着很多问题。
（1）会话连接是异步的，需要自己去处理。比如使用 CountDownLatch （2）Watch 需要重复注册，不然就不能生效 （3）开发的复杂性还是比较高的 （4）不支持多节点删除和创建。需要自己去递归 所以就引出了下面的案例：👇👇👇
3.Curator框架实现分布式锁案例
Curator 是一个专门解决分布式锁的框架，解决了原生 JavaAPI 开发分布式遇到的问题。 详情请查看官方文档： https://curator.apache.org/index.html 要使用它，就需要在pom文件中添加相关依赖。
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>RELEASE</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.8.2</version>
</dependency>
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.5.7</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-framework</artifactId>
<version>4.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-recipes</artifactId>
<version>4.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-client</artifactId>
<version>4.3.0</version>
</dependency>package com.szh.case3;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;
import java.util.concurrent.TimeUnit;
/**
*
*/
public class CuratorLockTest
public static void main(String[] args)
//创建分布式锁1
InterProcessMutex lock1 = new InterProcessMutex(getZkClient(), "/locks");
//创建分布式锁2
InterProcessMutex lock2= new InterProcessMutex(getZkClient(), "/locks");
//下面创建两个线程
new Thread(() ->
try
lock1.acquire(); //获取锁
System.out.println(Thread.currentThread().getName() + " 首次获取到锁....");
lock1.acquire();
System.out.println(Thread.currentThread().getName() + " 再次获取到锁....");
TimeUnit.MILLISECONDS.sleep(5000);
lock1.release(); //释放锁
System.out.println(Thread.currentThread().getName() + " 首次释放锁....");
lock1.release();
System.out.println(Thread.currentThread().getName() + " 再次释放锁....");
catch (Exception e)
e.printStackTrace();
).start();
new Thread(() ->
try
lock2.acquire();
System.out.println(Thread.currentThread().getName() + " 首次获取到锁....");
lock2.acquire();
System.out.println(Thread.currentThread().getName() + " 再次获取到锁....");
TimeUnit.MILLISECONDS.sleep(5000);
lock2.release();
System.out.println(Thread.currentThread().getName() + " 首次释放锁....");
lock2.release();
System.out.println(Thread.currentThread().getName() + " 再次释放锁....");
catch (Exception e)
e.printStackTrace();
).start();
private static CuratorFramework getZkClient()
//客户端和服务器连接失败之后，多少秒之后再进行重试，以及重试的次数，5000ms之后重试，重试3次
ExponentialBackoffRetry policy = new ExponentialBackoffRetry(5000, 3);
CuratorFramework client = CuratorFrameworkFactory.builder()
.connectString("192.168.40.130:2181")
.connectionTimeoutMs(20000)
.sessionTimeoutMs(30000)
.retryPolicy(policy).build();
//启动zk客户端
client.start();
System.out.println("zookeeper 启动成功....");
return client;
4.Zookeeper常见面试题
半数机制，超过半数的投票通过，即通过。 （1）第一次启动选举规则： 投票过半数时，服务器 id 大的胜出 （2）第二次启动选举规则： ①EPOCH 大的直接胜出 ②EPOCH 相同，事务 id 大的胜出 ③事务 id 相同，服务器 id 大的胜出
- 选举机制
安装奇数台。 生产经验： 10 台服务器：3 台 zk 20 台服务器：5 台 zk 100 台服务器：11 台 zk 200 台服务器：11 台 zk 服务器台数多：好处，提高可靠性；坏处：提高通信延时
- 生产集群安装多少 zk 合适？
- 常用命令 ：ls、get、create、delete
以上是关于Zookeeper——分布式锁的概念理解 & 应用举例的主要内容，如果未能解决你的问题，请参考以下文章