Zookeeper分布式锁

已于 2022-05-25 10:38:13 修改
阅读量2.4k 收藏 7
点赞数 2
分类专栏： # Zookeeper 文章标签： Zookeeper分布式锁
于 2022-05-23 23:05:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42402854/article/details/124936895
版权

实现一把分布式锁通常有很多方法，比较常见的有 Redis 和 Zookeeper。

Redis分布式锁可参考之前的文章：

Zookeeper能实现分布式锁，是因为它有一个特性，就是多个线程去 Zookeeper 里面去创建同一个节点的时候，只会有一个线程执行成功。

锁可理解为 ZooKeeper 上的一个节点，

  • 当需要获取锁时，就在这个锁节点下创建一个临时顺序节点。当存在多个客户端同时来获取锁，就按顺序依次创建多个临时顺序节点，但只有排列序号是第一的那个节点能获取锁成功，其他节点则按顺序分别监听前一个节点的变化，当被监听者释放锁时，监听者就可以马上获得锁。
  • 当释放锁时，只需要将会话关闭，临时节点就删除了，即释放了锁。如果万一客户端获取到锁之后突然挂掉（Session连接断开），那么这个临时节点也会自动删除掉。

Zookeeper 的分布式锁实现： 实现有两种方案：

  1. 基于临时节点实现，会产生羊群效应，不推荐。
  2. 基于临时顺序节点实现。

一般我们认为，ZooKeeper 的分布式锁是基于临时顺序节点，然后通过监听机制来实现的。即方案2。

一、基于临时节点实现

1、实现思路

在这里插入图片描述
锁节点：即锁对象

获取锁：锁请求者加锁，则创建锁节点。

  • 如果创建成功，那么加锁成功，
  • 如果创建失败，那么加锁失败，则等待获取锁（等待获取锁成功的客户端释放锁）。注意：这里锁请求者监听的都是 锁节点的删除操作。

释放锁：只需要将会话关闭，临时节点就删除了，即释放了锁。

羊群效应：如果所有的锁请求者都来监听锁持有者，当锁持有者的节点被删除以后，所有的锁请求者都会通知到，即都会同时去竞争锁，但是只有一个锁请求者能拿到锁。这就是羊群效应。

2、实现代码

一般不推荐使用。这里我们自己简单实现一下。使用的是 ZkClient客户端。

2.1 ZkClient客户端连接

public class ZkClientConnectUtils {

    private static String CONNECT_STR = "192.168.xxx.xxx:2181"; //集群模式下用逗号隔开

    /**
     * 使用匿名监听类
     * @throws Exception
     */
    public static ZkClient zKClientConnnect() throws Exception {
        ZkClient zkClient = new ZkClient(CONNECT_STR, 3000,60000);
        TimeUnit.SECONDS.sleep(3);
        return zkClient;
    }

}

2.2 锁实现

2.2.1 锁接口
/**
 * 自定义zk分布式锁：定义通用锁接口
 */
public interface ZKLock {

    /**
     * 加锁
     */
    void lock();

    /**
     * 释放锁
     */
    void unlock();
}
2.2.2 抽象锁对象
/**
 * 抽象锁对象：用到了模板方法设计模式，具体抽象方法由子类实现
 */
public abstract class AbstractZKLock implements ZKLock {

    protected static String path = "/lock";

    protected ZkClient zkClient = null;

    public AbstractZKLock() {
        initClient();
    }

    public void initClient(){
        try {
            zkClient = createClient();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("初始化 zk客户端连接失败，errorMessage=" + e.getMessage());
        }
    }

    /**
     * 交给子类创建
     * @return
     */
    protected abstract ZkClient createClient()  throws Exception;

    /**
     * lock方法（模板方法设计模式）：获取锁的方法
     *   1.如果锁获取成功，那么业务代码继续往下走。
     *   2.如果锁获取失败，lock方法需要等待重新获取锁
     *      2.1等待到了前面那个获取锁的客户端释放锁以后（zk监听机制），
     *      2.2然后再去重新获取锁
     */
    @Override
    public void lock() {
        // 尝试去获取锁
        if(tryLock()){
            System.out.println(Thread.currentThread().getName() + "--->获取锁成功！");
        }else {
            // 获取失败，在这里等待
            waitforlock();
            // 重新获取锁
            lock();
        }
    }

    @Override
    public void unlock() {
        // 因为加锁创建的是临时节点，所以会话关闭，临时节点就删除了，即释放了锁
        zkClient.close();
    }

    /**
     * 获取锁
     * @return
     */
    protected abstract boolean tryLock();

    /**
     * 获取失败，等待其他释放锁，重新获取锁
     */
    protected abstract void waitforlock();
}
2.2.3 ZkClient客户端实现
/**
 * 基于ZkClient客户端实现锁：
 */
public class ZkClientLock extends AbstractZKLock {

    private CountDownLatch cdl = null;

    @Override
    protected ZkClient createClient() throws Exception{
        return ZkClientConnectUtils.zKClientConnnect();
    }

    /**
     * 尝试获取锁
     * @return
     */
    @Override
    protected boolean tryLock() {
        try {
            // 加锁：创建临时节点，创建成功表示加锁成功，否则加锁失败。zookeeper 的特性，节点名不能重复，否则创建失败。
            if(zkClient.exists(path)) {
                zkClient.delete(path);
            }
            //创建临时节点
            zkClient.createEphemeral(path);
            return true;
        } catch (RuntimeException e) {
            return false;
        }
    }

    /**
     * 等待获取锁:
     * 等前面那个获取锁成功的客户端释放锁
     * 没有获取到锁的客户端都会走到这里
     * 1、没有获取到锁的要注册对 path节点的watcher
     * 2、这个方法需要等待
     */
    @Override
    protected void waitforlock() {
        IZkDataListener iZkDataListener = new IZkDataListener() {

            @Override
            public void handleDataChange(String dataPath, Object data) throws Exception {

            }

            // 一旦 path节点被删除（释放锁）以后，就会触发这个方法
            @Override
            public void handleDataDeleted(String dataPath) throws Exception {
                // 让等待的代码不再等待了
                // 即 waitforlock方法执行结束，重新去获取锁
                if (cdl != null) {
                    cdl.countDown();
                }
            }
        };
        // 注册对 path节点的watcher
        zkClient.subscribeDataChanges(path, iZkDataListener);

        // 等待
        if (zkClient.exists(path)) {
            cdl = new CountDownLatch(1);
            try {
                cdl.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 取消该客户端的订阅关系
        zkClient.unsubscribeDataChanges(path, iZkDataListener);
    }
}

2.3 业务代码

public class OrderService {
    private OrderNumGenereteUtils orderNumFactory = new OrderNumGenereteUtils();

    // ZkClient分布式锁
    private ZKLock lock = new ZkClientLock();

    /**
     * 创建订单号，模拟业务
     */
    public void createOrderNum() {
        lock.lock();
        String orderNum = generateOrderNum();
        System.out.println(Thread.currentThread().getName() + "创建了订单号：[" + orderNum + "]");
        lock.unlock();
    }


    /**
     * 生成时间格式的订单编号
     * @return
     */
    private static int orderNum = 0;
    public String generateOrderNum() {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss-");
        return simpleDateFormat.format(new Date()) + ++orderNum;
    }

}

2.4 测试

public class ZkClientLockTest {

    private static Integer count = 50;
    private static CountDownLatch cdl = new CountDownLatch(count);

    public static void main(String[] args) throws InterruptedException {

        for (int i = 0; i < count; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    // 模拟50个并发同时去创建订单号。
                    OrderService orderService = new OrderService();
                    try {
                        //线程运行起来时先等待。
                        cdl.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    orderService.createOrderNum();
                }
            }).start();
            cdl.countDown();
        }
        TimeUnit.MINUTES.sleep(3);
    }
}

并发模拟 50个线程同时去创建订单号。运行ok。
在这里插入图片描述

二、基于临时顺序节点实现

1、实现思路

在这里插入图片描述
锁节点：即锁对象

获取锁：锁请求者加锁，则创建锁节点。

  • 如果创建成功，那么加锁成功，
  • 如果创建失败，那么加锁失败，则等待它的前一个节点释放锁。注意：这里锁请求者监听的是它上一个节点的删除操作。

释放锁：只需要将会话关闭，临时节点就删除了，即释放了锁。

2、示例代码

在实际的开发中，建议直接使用 Curator客户端中的各种官方实现的分布式锁。我们没必要“重复造轮子“”。

Curator客户端提供的 几种锁方案：

  • InterProcessMutex：分布式可重入排它锁
  • InterProcessSemaphoreMutex：分布式排它锁
  • InterProcessReadWriteLock：分布式读写锁

下面我们以 InterProcessMutex为例。

2.1 Curator客户端连接

前面文章有介绍过 Curator客户端的使用。

public class CuratorClientConnectUtils {

    private static String CONNECT_STR = "192.168.198.110:2181"; //集群模式下用逗号隔开

    private static class InnerClass{
        private static CuratorFramework client = clientConnect2();
    }

    public static CuratorFramework getInstance(){
        return InnerClass.client;
    }


    public static void main(String[] args){
        //CuratorFramework client = clientConnect1();
        CuratorFramework client = clientConnect2();
        //启动客户端，必须要有
        client.start();
        System.out.println("==CuratorFramework==" + client);
    }

    /**
     * 使用工厂类CuratorFrameworkFactory的静态newClient()方法。
     * @throws Exception
     */
    public static CuratorFramework clientConnect1() {
        // 重试策略, 失败重连3次
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(100, 3);
        //创建客户端实例
        CuratorFramework client = CuratorFrameworkFactory.newClient(CONNECT_STR, retryPolicy);
        return client;

    }

    /**
     * 使用工厂类CuratorFrameworkFactory的静态builder构造者方法。
     * @throws Exception
     */
    public static CuratorFramework clientConnect2() {
        // 重试策略, 失败重连3次
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(100, 3);
        CuratorFramework client = CuratorFrameworkFactory.builder()
            .connectString(CONNECT_STR)
            .sessionTimeoutMs(3000) // 会话超时时间
            .connectionTimeoutMs(50000) // 连接超时时间
            .retryPolicy(retryPolicy)
            .namespace("Curator_Workspace") // 指定隔离名称，表示所有节点的操作都会在该工作空间下进行。不指定时，使用自定义的节点path
            .build();
       return client;
    }

    public static void closeZKClient() {
        if (InnerClass.client != null) {
            InnerClass.client.close();
        }
    }
}

2.2 业务代码

public class OrderService {

    /**
     * 分布式可重入排它锁
     */
    public InterProcessMutex interProcessMutex;

    // 简单点，构造方法注入锁实例
    public OrderService(InterProcessMutex interProcessMutex) {
        this.interProcessMutex = interProcessMutex;
    }

    /**
     * 创建订单号，模拟业务
     */
    public void createOrderNum() throws Exception {
        //加锁
        interProcessMutex.acquire();
        String orderNum = generateOrderNum();
        System.out.println(Thread.currentThread().getName() + "创建了订单号：[" + orderNum + "]");
        //释放锁
        interProcessMutex.release();
    }

    /**
     * 生成时间格式的订单编号
     * @return
     */
    private static int orderNum = 0;
    public String generateOrderNum() {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss-");
        return simpleDateFormat.format(new Date()) + ++orderNum;
    }
}

2.3 测试

public class InterProcessMutexTest {

    private static Integer count = 50;
    private static CountDownLatch cdl = new CountDownLatch(count);

    public static void main(String[] args) {

        CuratorFramework client = CuratorClientConnectUtils.getInstance();
        client.start();

        InterProcessMutex interProcessMutex = new InterProcessMutex(client, "/curator/lock");
        for (int i = 0; i < count; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    // 模拟50个并发同时去创建订单号。
                    OrderService orderService = new OrderService(interProcessMutex);
                    try {
                        //线程运行起来时先等待。
                        cdl.await();
                        orderService.createOrderNum();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
            cdl.countDown();
        }

    }

}

并发模拟 50个线程同时去创建订单号。运行ok。
在这里插入图片描述
注意：我们可以通过锁的构造方法传入path。不传时底层path会有默认值。
在这里插入图片描述

下面简单看一下 Curator客户端实现分布式锁的源码。

3、加锁源码

3.1 查看acquire() -> internalLock()方法
在这里插入图片描述

3.2 查看 attemptLock()方法
在这里插入图片描述
上面 createsTheLock()方法和 internalLockLoop()方法是重点。底层都是 Curator客户端的API使用。

3.2.1 createsTheLock()方法：

级联创建临时有序节点，即获取锁逻辑。返回节点路径。
在这里插入图片描述

3.2.2 internalLockLoop()方法

这个方法实现了 监听的机制，自行查看。

注意：usingWatcher是一次性监听。

client.getData().usingWatcher(watcher).forPath(previousSequencePath);

private boolean internalLockLoop(long startMillis, Long millisToWait, String ourPath) throws Exception
    {
        boolean     haveTheLock = false;
        boolean     doDelete = false;
        try
        {
            if ( revocable.get() != null )
            {
                client.getData().usingWatcher(revocableWatcher).forPath(ourPath);
            }

            while ( (client.getState() == CuratorFrameworkState.STARTED) && !haveTheLock )
            {
                List<String>        children = getSortedChildren();
                String              sequenceNodeName = ourPath.substring(basePath.length() + 1); // +1 to include the slash

                PredicateResults    predicateResults = driver.getsTheLock(client, children, sequenceNodeName, maxLeases);
                if ( predicateResults.getsTheLock() )
                {
                    haveTheLock = true;
                }
                else
                {
                    String  previousSequencePath = basePath + "/" + predicateResults.getPathToWatch();

                    synchronized(this)
                    {
                        try
                        {
                            // use getData() instead of exists() to avoid leaving unneeded watchers which is a type of resource leak
                            client.getData().usingWatcher(watcher).forPath(previousSequencePath);
                            if ( millisToWait != null )
                            {
                                millisToWait -= (System.currentTimeMillis() - startMillis);
                                startMillis = System.currentTimeMillis();
                                if ( millisToWait <= 0 )
                                {
                                    doDelete = true;    // timed out - delete our node
                                    break;
                                }

                                wait(millisToWait);
                            }
                            else
                            {
                                wait();
                            }
                        }
                        catch ( KeeperException.NoNodeException e )
                        {
                            // it has been deleted (i.e. lock released). Try to acquire again
                        }
                    }
                }
            }
        }
        catch ( Exception e )
        {
            ThreadUtils.checkInterrupted(e);
            doDelete = true;
            throw e;
        }
        finally
        {
            if ( doDelete )
            {
                deleteOurPath(ourPath);
            }
        }
        return haveTheLock;
    }

4、解锁源码

4.1 查看 release()方法
在这里插入图片描述

4.2 查看releaseLock()方法
在这里插入图片描述

– 求知若饥，虚心若愚。

Charge8
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
zookeeper分布式锁
02-18
此Demo采用zookeeper实现分布式锁,相比于redis实现分布式锁更加可靠
zookeeper实现分布式锁
凉茶铺的博客
10-28 6522
介绍了Zookeeper如何实现分布式锁，并使用代码进行了演示
基于Zookeeper实现分布式锁
weixin_45125989的博客
05-04 2476
在Zookeeper中的指定路径下创建创建节点，然后客户端根据当前路径下的节点状态来判断是否加锁成功，如下图一种情况为例，线程1创建节点成功后，线程2再去创建节点就会创建失败。（3）如果加锁次数等于0，则释放锁，删除掉创建的临时节点，下一个监听这个节点的客户端会感知到节点删除事件，从而重新去获取锁。3：判断自己的序号是否最小，如果最小的话，代表加锁成功，如果不是最小的话，就对前一个节点创建监听器。2：使用顺序节点的好处是，可以利用锁释放的事件监听机制，来实现。2：第二步客户端拿到加锁路径下所有创建的节点。
Zookeeper实现分布式锁（Zk分布式锁）
最新发布
刘皇叔说Java的博客
03-23 1020
基于zookeeper临时有序节点可以实现的分布式锁。1、zookeeper天生设计定位就是分布式协调，强一致性。锁的模型健壮、简单易用、适合做分布式锁。2、如果获取不到锁，只需要添加一个监听器就可以了，不用一直轮询，性能消耗较小。3、如果有较多的客户端频繁的申请加锁、释放锁，对于zk集群的压力会比较大。
Zookeeper 分布式锁、队列
杨宇昌的博客
04-26 2550
Zookeeper 分布式锁
ZooKeeper实现分布式锁
北辰
05-27 559
以下订单为例，假设当前有10个库存，一次请求下订单（6个）的时候创建订单后去扣除库存速度变慢了，那么下一个请求过来的时候去查询库存就发现库存还是10个，然后也会去执行创建订单和扣除库存这么一个操作，最终两个请求都成功了，库存变为-2，和实际生活不一致，这个时候就需要引入分布式锁。监听子节点是否已被移除，如果是的话，则触发同步计数器（countdownlatch）的自减操作，当countdownlacth的值为0的时候，前面阻塞的线程就可以继续往下执行了，即分布式的请求可以执行了。...
一文彻底理解ZooKeeper分布式锁的实现原理
01-20
二、ZooKeeper分布式锁机制 接下来我们一起来看看，多客户端获取及释放zk分布式锁的整个流程及背后的原理。 首先大家看看下面的图，如果现在有两个客户端一起要争抢zk上的一把分布式锁，会是个什么场景？ 如果大家...
zookeeper 分布式锁
05-10
利用zookeeper 实现分布式锁
zookeeper 分布式锁的实现1
08-08
zookeeper 分布式锁的实现1
Zookeeper分布式锁的4种异常状态分析.pdf
08-08
#资源达人分享计划#
进阶分布式系统架构系列（十三）：Zookeeper 分布式锁原理与实现
民工哥的博客
09-02 188
点击下方名片，设为星标！回复“1024”获取2TB学习资源！前面介绍了 Zookeeper集群 ZAB 协议、配置中心、注册中心、数据与存储、会话与事务管理等相关的知识点，今天我将详细的为大家介绍 zookeeper 分布式锁相关知识，希望大家能够从中收获多多！如有帮助，请点在看、转发支持一波！！！什么是分布式锁？在平时我们对锁的使用，在针对单个服务，我们可以用 Java 自带的一些锁来实现，资...
基于zookeeper实现分布式锁
一个菜鸡的博客
05-04 2115
如果创建的是永久的节点，那么这个锁永远不会释放，导致死锁；例如子节点列表 为/lock/lock-0000000000、/lock/lock-0000000001、/lock/lock-0000000002，序号为1的客户端监听 序号为0的子节点删除消息，序号为2的监听序号为1的子节点删除消息。客户端获取/lock下的子节点列表，判断自己创建的子节点是否为当前子节点列表中序号最小的子 节点，如果是则认为获得锁，否则监听刚好在自己之前一位的子节点删除消息，获得子节点变更通 知后重复此步骤直至获得锁；
Zookeeper学习(九)：ZooKeeper 实现分布式锁
xiajie的专栏
03-21 2647
1.什么是分布式锁        一般的锁：一般我们说的锁是但进程多线程的锁，在多线程并发编程中，用于线程之间的数据同步，保护共享资源的访问        分布式锁：分布式锁指的是在分布式环境下，保护跨进程，跨主机，跨网络的共享资源，实现互斥访问，保证一致性 2.分布式锁的架构图 3.分布式锁的算法流程
ZooKeeper实现分布式锁（一）
Discovery的专栏
05-29 911
ZooKeeper可以在其目录下建立节点，这些节点都是以路径和值为映射关系存在的，下面通过一个例子说明如何创建节点和删除节点。public class TestLock { public static void main(String[] args) { ZkClient zkClient1 = new ZkClient(new ZkConnection("127.0.0.1:2181")...
ZooKeeper-分布式锁实现
qq_40432598的博客
01-19 2476
ZooKeeper-分布式锁实现
Zookeeper实战——分布式锁实现以及原理
KIMTOU的博客
05-18 9156
文章目录Zookeeper 分布式锁实现原理具体流程代码实现客户端创建工厂类创建 Lock 锁接口Lock 实现类（ZkLock）自定义 ZK 分布式锁测试独占锁 & 共享锁Curator 实现分布式锁ZooKeeper 分布式锁的优缺点 分布式锁是控制分布式系统之间同步访问共享资源的一种方式。分布式锁的实现方式有很多种，比如 Redis 、数据库 、zookeeper 等。这篇文章主要介绍用 Zookeeper 实现分布式锁。 Zookeeper 分布式锁实现原理 先说结论：Zookeeper.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值