【欢迎关注公众号:程序猿讲故事 (codestory),及时接收最新文章】

今天介绍基于ZooKeeper的分布式锁的简单实现,包括阻塞锁和非阻塞锁。同时增加了网上很少介绍的基于节点的非阻塞锁实现,主要是为了加深对ZooKeeper的理解。

维基百科:分布式锁,是控制分布式系统之间同步访问共享资源的一种方式。在分布式系统中,常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源,那么访问这些资源的时候,往往需要互斥来防止彼此干扰来保证一致性,在这种情况下,便需要使用到分布式锁。

1      阻塞锁和非阻塞锁

根据业务特点,普通分布式锁有两种需求:阻塞锁和非阻塞锁。

阻塞锁:多个系统同时调用同一个资源,所有请求被排队处理。已经得到分布式锁的系统,进入运行状态完成业务操作;没有得到分布式锁的线程进入阻塞状态等待,当获得相应的信号并获得分布式锁后,进入运行状态完成业务操作。

非阻塞锁:多个系统同时调用同一个资源,当某一个系统最先获取到锁,进入运行状态完成业务操作;其他没有得到分布式锁的系统,就直接返回,不做任何业务逻辑,可以给用户提示进行其他操作。

2      锁代码简单设计

基于ZooKeeper实现锁,一般都是创建EPHEMERAL_SEQUENTIAL子节点并比较序号实现的。参照Redis的分布式锁实现,也可以使用EPHEMERAL节点实现。

3      分布式锁代码

完整代码比较多,占篇幅。在文中只保留了关键的代码。完整项目代码放到了github(https://github.com/SeemSilly/codestory/tree/master/research-zoo-keeper),感兴趣的可以关注。

3.1   分布式锁接口定义

ZooKeeperLock.java

public interface ZooKeeperLock {

/**

* 尝试获取锁

*

* @param guidNodeName 用于加锁的唯一节点名

* @param clientGuid 用于唯一标识当前客户端的ID

* @return

*/

boolean lock(String guidNodeName, String clientGuid);

/**

* 释放锁

*

* @param guidNodeName 用于加锁的唯一节点名

* @param clientGuid 用于唯一标识当前客户端的ID

* @return

*/

boolean release(String guidNodeName, String clientGuid);

/**

* 锁是否已经存在

*

* @param guidNodeName 用于加锁的唯一节点名

* @return

*/

boolean exists(String guidNodeName);

}

3.2   基于节点实现的非阻塞锁

NodeBlocklessLock.java

public class NodeBlocklessLock extends ZooKeeperBase implements ZooKeeperLock {

/** 尝试获取锁 */

public boolean lock(String guidNodeName, String clientGuid) {

boolean result = false;

if (getZooKeeper().exists(guidNodeName, false) == null) {

getZooKeeper().create(guidNodeName, clientGuid.getBytes(),

ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);

byte[] data = getZooKeeper().getData(guidNodeName, false, null);

if (data != null && clientGuid.equals(new String(data))) {

result = true;

}

}

return result;

}

/** 释放锁 */

public boolean release(String guidNodeName, String clientGuid) {

boolean result = false;

Stat stat = new Stat();

byte[] data = getZooKeeper().getData(guidNodeName, false, stat);

if (data != null && clientGuid.equals(new String(data))) {

getZooKeeper().delete(guidNodeName, stat.getVersion());

result = true;

}

return result;

}

/** 锁是否已经存在 */

public boolean exists(String guidNodeName) {

boolean result = false;

Stat stat = getZooKeeper().exists(guidNodeName, false);

result = stat != null;

return result;

}

}

3.3   基于子节点实现的分布式锁基类

ChildrenNodeLock.java

public abstract class ChildrenNodeLock extends ZooKeeperBase implements ZooKeeperLock {

/** 获取当前节点的前一个节点,如果为空表示自己是第一个 */

protected String getPrevElementName() {

List<String> elementNames = getZooKeeper().getChildren(this.guidNodeName, false);

long curElementSerial = Long.valueOf(

elementNodeFullName.substring((this.guidNodeName + "/" + childPrefix).length()));

String prevElementName = null;

long prevElementSerial = -1;

for (String oneElementName : elementNames) {

long oneElementSerial = Long.parseLong(oneElementName.substring(childPrefix.length()));

if (oneElementSerial < curElementSerial) {

// 比当前节点小

if (oneElementSerial > prevElementSerial) {

prevElementSerial = oneElementSerial;

prevElementName = oneElementName;

}

}

}

return prevElementName;

}

/** 尝试获取锁 */

public boolean lock(String guidNodeName, String clientGuid) {

boolean result = false;

// 确保根节点存在,并且创建为容器节点

super.createRootNode(this.guidNodeName, CreateMode.CONTAINER);

// 创建子节点并返回带序列号的节点名

elementNodeFullName = getZooKeeper().create(this.guidNodeName + "/" + childPrefix,

new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);

boolean lockSuccess = isLockSuccess();

result = lockSuccess;

return result;

}

/** 释放锁 */

public boolean release(String guidNodeName, String clientGuid) {

// 删除子节点

getZooKeeper().delete(elementNodeFullName, 0);

return true;

}

/** 锁是否已经存在,容器节点存在,并且有子节点,则说明锁已经存在 */

public boolean exists(String guidNodeName) {

boolean exists = false;

Stat stat = new Stat();

try {

getZooKeeper().getData(guidNodeName, false, stat);

exists = stat.getNumChildren() > 0;

} catch (KeeperException.NoNodeException e) {

exists = false;

}

return exists;

}

/** 是否加锁成功 , 由子类实现 */

protected abstract boolean isLockSuccess();

}

3.4   基于子节点实现的非阻塞锁

ChildrenBlocklessLock.java

public class ChildrenBlocklessLock extends ChildrenNodeLock {

/** 是否加锁成功 */

protected boolean isLockSuccess() throws KeeperException, InterruptedException {

boolean lockSuccess = false;

String prevElementName = getPrevElementName();

if (prevElementName != null) {

// 有更小的节点,说明当前节点没抢到锁,删掉自己并退出

getZooKeeper().delete(elementNodeFullName, 0);

} else {

lockSuccess = true;

}

return lockSuccess;

}

}

3.5   基于子节点实现的阻塞锁

ChildrenBlockingLock.java

public class ChildrenBlockingLock extends ChildrenNodeLock {

/** 前一个节点被删除的信号 */

static Integer mutex = Integer.valueOf(-1);

/** 监控的节点被删除 */

protected void processNodeDeleted(WatchedEvent event) {

synchronized (mutex) {

// 节点被删除,通知退出线程

mutex.notify();

}

}

/** 是否加锁成功 */

protected boolean isLockSuccess() {

boolean lockSuccess;

while (true) {

String prevElementName = getPrevElementName();

if (prevElementName == null) {

lockSuccess = true;

break;

} else {

// 有更小的节点,说明当前节点没抢到锁,注册前一个节点的监听

getZooKeeper().exists(this.guidNodeName + "/" + prevElementName, true);

synchronized (mutex) {

mutex.wait();

log.info("{} 被删除,看看是不是轮到自己了", prevElementName);

}

}

}

return lockSuccess;

}

}

4      测试用例

4.1   测试代码

LockClientThread.java 获取分布式锁和释放锁

public class LockClientThread extends Thread {

/** 模拟获取分布式锁,成功后执行业务 */

public void run() {

boolean locked = zooKeeperLock.lock(guidNodeName, clientGuid);

if (locked) {

log.info("{} lock() success,拿到锁了,假装忙2秒", clientGuid);

Thread.sleep(2000);

boolean released = zooKeeperLock.release(guidNodeName, clientGuid);

log.info("{} release() result : {}", clientGuid, released);

} else {

log.info("{} lock() fail", clientGuid);

}

}

}

模拟多个客户端并发执行

public void testChildrenBlocklessMultiThread() throws IOException {

String guidNodeName = "/multi-" + System.currentTimeMillis();

int threadCount = 5;

LockClientThread[] threads = new LockClientThread[threadCount];

for (int i = 0; i < threadCount; i++) {

ChildrenBlocklessLock nodeBlocklessLock = new ChildrenBlocklessLock(address);

threads[i] = new LockClientThread(nodeBlocklessLock, guidNodeName, "client-" + (i + 1));

}

for (int i = 0; i < threadCount; i++) {

threads[i].start();

}

}

4.2   非阻塞锁的测试结果

可以看到,只有一个线程能抢到锁并执行业务,其他线程都直接退出。

55:43.929 [INFO] LockClientThread.run(33) client-1 lock() ...

55:43.942 [INFO] LockClientThread.run(33) client-3 lock() ...

55:43.947 [INFO] LockClientThread.run(33) client-2 lock() ...

55:43.948 [INFO] LockClientThread.run(33) client-4 lock() ...

55:43.949 [INFO] LockClientThread.run(33) client-5 lock() ...

55:44.052 [INFO] LockClientThread.run(36) client-1 lock() success,拿到锁了,假装忙2秒

55:44.072 [INFO] LockClientThread.run(47) client-5 lock() fail

55:44.085 [INFO] LockClientThread.run(47) client-4 lock() fail

55:44.091 [INFO] LockClientThread.run(47) client-2 lock() fail

55:44.096 [INFO] LockClientThread.run(47) client-3 lock() fail

55:46.053 [INFO] LockClientThread.run(42) client-1 release() ...

55:46.057 [INFO] LockClientThread.run(44) client-1 release() result : true

4.3   阻塞锁的测试结果

可以看到,抢到分布式锁的线程执行业务,没抢到锁的线程会等到直到锁被释放重新获取到锁后再执行业务。

59:32.802 [INFO] LockClientThread.run(33) client-1 lock() ...

59:32.811 [INFO] LockClientThread.run(33) client-3 lock() ...

59:32.812 [INFO] LockClientThread.run(33) client-4 lock() ...

59:32.813 [INFO] LockClientThread.run(33) client-2 lock() ...

59:32.813 [INFO] LockClientThread.run(33) client-5 lock() ...

59:32.836 [INFO] LockClientThread.run(36) client-1 lock() success,拿到锁了,假装忙2秒

59:34.836 [INFO] LockClientThread.run(42) client-1 release() ...

59:34.844 [INFO] LockClientThread.run(44) client-1 release() result : true

59:34.846 [INFO] ChildrenBlockingLock.isLockSuccess(55) element0000000000 被删除,看看是不是轮到自己了

59:34.848 [INFO] LockClientThread.run(36) client-5 lock() success,拿到锁了,假装忙2秒

59:36.848 [INFO] LockClientThread.run(42) client-5 release() ...

59:36.852 [INFO] ChildrenBlockingLock.isLockSuccess(55) element0000000001 被删除,看看是不是轮到自己了

59:36.852 [INFO] LockClientThread.run(44) client-5 release() result : true

59:36.855 [INFO] LockClientThread.run(36) client-2 lock() success,拿到锁了,假装忙2秒

59:38.855 [INFO] LockClientThread.run(42) client-2 release() ...

59:38.869 [INFO] ChildrenBlockingLock.isLockSuccess(55) element0000000002 被删除,看看是不是轮到自己了

59:38.870 [INFO] LockClientThread.run(44) client-2 release() result : true

59:38.876 [INFO] LockClientThread.run(36) client-4 lock() success,拿到锁了,假装忙2秒

59:40.877 [INFO] LockClientThread.run(42) client-4 release() ...

59:40.881 [INFO] ChildrenBlockingLock.isLockSuccess(55) element0000000003 被删除,看看是不是轮到自己了

59:40.882 [INFO] LockClientThread.run(44) client-4 release() result : true

59:40.884 [INFO] LockClientThread.run(36) client-3 lock() success,拿到锁了,假装忙2秒

59:42.884 [INFO] LockClientThread.run(42) client-3 release() ...

59:42.887 [INFO] LockClientThread.run(44) client-3 release() result : true

基于ZooKeeper的三种分布式锁实现的更多相关文章

  1. 基于Redis的三种分布式爬虫策略

    前言: 爬虫是偏IO型的任务,分布式爬虫的实现难度比分布式计算和分布式存储简单得多. 个人以为分布式爬虫需要考虑的点主要有以下几个: 爬虫任务的统一调度 爬虫任务的统一去重 存储问题 速度问题 足够“ ...

  2. 基于zookeeper或redis实现分布式锁

    前言 在分布式系统中,分布式锁是为了解决多实例之间的同步问题.例如master选举,能够获取分布式锁的就是master,获取失败的就是slave.又或者能够获取锁的实例能够完成特定的操作. 目前比较常 ...

  3. 三种分布式锁 简易说说(包含前一篇提到的redis分布式锁)

    大多数互联网系统都是分布式部署的,分布式部署确实能带来性能和效率上的提升,但为此,我们就需要多解决一个分布式环境下,数据一致性的问题. 当某个资源在多系统之间,具有共享性的时候,为了保证大家访问这个资 ...

  4. 服务注册中心之ZooKeeper系列(三) 实现分布式锁

    通过ZooKeeper的有序节点.节点路径不回重复.还有节点删除会触发Wathcer事件的这些特性,我们可以实现分布式锁. 一.思路 zookeeper中创建一个根节点Locks,用于后续各个客户端的 ...

  5. ZooKeeper的三种典型应用场景

    引言 ZooKeeper是中典型的pub/sub模式的分布式数据管理与协调框架,开发人员可以使用它进行分布式数据的发布与订阅.另外,其丰富的数据节点类型可以交叉使用,配合Watcher事件通知机制,可 ...

  6. Zookeeper是如何实现分布式锁的

    [toc] Zookeeper是如何实现分布式锁的 标签 : Zookeeper 分布式 实现分布式锁要考虑的重要问题 1. 三个核心要素 加锁, 解锁, 锁超时 2. 三个问题 要保证原子性操作, ...

  7. (三)Redis &分布式锁

    1 Redis使用中的常见问题和解决办法 1.1 缓存穿透 定义:缓存系统都是按照key去缓存查询,如果不存在对应的value,就应该去DB查找.一些恶意的请求会故意查询不存在的key,请求量很大,就 ...

  8. Apache Spark探秘:三种分布式部署方式比较

    转自:链接地址: http://dongxicheng.org/framework-on-yarn/apache-spark-comparing-three-deploying-ways/     目 ...

  9. SpringBoot基于数据库实现简单的分布式锁

    本文介绍SpringBoot基于数据库实现简单的分布式锁. 1.简介 分布式锁的方式有很多种,通常方案有: 基于mysql数据库 基于redis 基于ZooKeeper 网上的实现方式有很多,本文主要 ...

随机推荐

  1. 用Python玩数据-笔记整理-第二章

    条件结构: if语句: if expression: #比较/成员/逻辑运算符 expr_true_suite #代码块必须缩进4个空格 else语句: if expression: expr_tru ...

  2. MyBatis OGNL表达式用法

    From<MyBatis从入门到精通> <!-- 4.7 OGNL用法 MyBatis常用的OGNL表达式: e1 or e2: e1 and e2 e1 == e2; e1 != ...

  3. blog更新

    特别感谢: yu__xuan (啊这位着重感谢,多次帮助,于是帮他宣传一下https://www.cnblogs.com/poi-bolg-poi/) widerg 为两位大佬撒花~

  4. 个人永久性免费-Excel催化剂功能第80波-按条件查找数字,扩展原生查找功能

    Excel的查找替换功能,只能对文本类数据查找较为得力,若需查找数字类型的数据,如查找大于100的数字,就无能为力,此篇Excel催化剂补足其短板. Excel数据类型知识背景介绍 用好Excel,必 ...

  5. 题解 P5367 【【模板】康托展开】

    P5367 [模板]康托展开 感觉这题难度大概在绿题到蓝题之间qwq 一.洛谷日报[yummy]浅谈康托展开 如我想知道321是{1,2,3}中第几个小的数可以这样考虑 : 第一位是3,当第一位的数小 ...

  6. CentOS 7.2配置LAMP环境——yum版

    环境:CentOS 7.2 采用putty连接 方法:采用yum安装方法 目的:搭建Apache+MySQL+PHP环境 1.安装Apache yum install httpd //默认情况下,选择 ...

  7. Java设计模式——工厂设计模式

    工厂模式:主要用来实例化有共同接口的类,工厂模式可以动态决定应该实例化那一个类.工厂模式的形态工厂模式主要用一下几种形态:1:简单工厂(Simple Factory).2:工厂方法(Factory M ...

  8. C#中判断socket是否已断开的方法

    记得以前Delphi/BCB里的socket编程,要判断[连接的另一方]是否断开了,只要在ondisconnect事件里处理就行了!如今在C#中,这个问题的确还是个问题哦!        首先,Soc ...

  9. JSON的简单使用之提取多层嵌套的JSON(C#)

    JSON.NET(http://json.codeplex.com/)使用来将.NET中的对象转换为JSON字符串(序列化?),或者将JSON字符串转换为.NET中已有类型的对象(反序列化?) 反序列 ...

  10. linux初学者-常用基本命令篇

    linux系统中有着许许多多的命令,并且软件也有可能自带命令,要想全部了解这些命令是很困难的,但是有一些基本命令是在平时的学习工作中应用的很广泛的.以下简要介绍几种linux系统中的常用命令. 1.m ...