Zookeeper的分布式锁例子（Curator）

最新推荐文章于 2024-05-01 06:33:01 发布
最新推荐文章于 2024-05-01 06:33:01 发布
阅读量404 收藏
点赞数
文章标签： zookeeper curator 分布式锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/duke_ding2/article/details/128355703
版权

环境

  • Ubuntu 22.04
  • Zookeeper 3.7.1
  • JDK 17.0.3.1
  • IntelliJ IDEA 2022.1.3
  • Curator 5.4.0

准备

创建Maven项目 test1217 。

打开 pom.xml 文件，添加如下依赖：

        <!-- https://mvnrepository.com/artifact/org.apache.curator/curator-recipes -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>5.4.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.curator/curator-framework -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>5.4.0</version>
        </dependency>

并发冲突

考虑一个应用场景：N个进程同时运行，并发访问某资源。

为了简单起见，用并发线程来模拟多进程。用整数10代表10个资源项。

如果不考虑并发冲突问题，代码如下：

package pkg4;

public class Test1 {
    private static int res = 10;

    public static void foo() {
        while (res > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + res);
            res--;
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                foo();
            }).start();
        }
    }
}

运行结果如下：

Thread-2 : 10
Thread-0 : 10
Thread-1 : 10
Thread-2 : 7
Thread-1 : 6
Thread-0 : 5
Thread-2 : 4
Thread-1 : 4
Thread-0 : 2
Thread-2 : 1
Thread-0 : 1
Thread-1 : 1

Process finished with exit code 0

该程序模拟了3个客户端应用，并发访问资源。具体逻辑为：打印现有的资源数量，并消耗一个资源。

代码逻辑里没有做并发控制，从打印结果可见，多个客户端可能会获取到同一份资源，造成错误。

具体问题包括：

  • res > 0 在并发情况下，即使判断还有资源，后面打印资源数量以及消耗资源时，可能已经是0了。
  • res-- 不是原子操作，在并发情况下，可能会产生“字撕裂”的问题（如果没记错可以使用 volatile 关键字解决）。

synchronized关键字

要解决并发冲突，就要引入同步机制。最简单的办法是用 synchronized 关键字修饰 foo() 方法，但是这样做太暴力了，因为 while 循环是在 foo() 方法里面的，这种做法会导致只能有一个客户端获取所有资源。

因此，需要把“访问资源”的逻辑提出来，单独创建一个 synchronized 方法，如下：

package pkg4;

public class Test2 {
    private static int res = 10;

    public synchronized static boolean bar() {
        if (res > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + res);
            res--;

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return true;
        } else {
            return false;
        }
    }
    public static void foo() {
        while (true) {
            boolean succ = bar();

            if (!succ) break;

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                foo();
            }).start();
        }
    }
}

运行结果如下：

Thread-0 : 10
Thread-2 : 9
Thread-1 : 8
Thread-2 : 7
Thread-0 : 6
Thread-2 : 5
Thread-1 : 4
Thread-2 : 3
Thread-0 : 2
Thread-1 : 1

这回没有问题，多个客户端无序的交替获取资源。

注意：循环里面在调用 bar()方法之后，最好sleep一会儿，给别的客户端机会，否则貌似当前客户端会继续获取下一个资源，别的客户端抢占不过它。

Zookeeper分布式锁（Curator）

使用Curator的锁机制，如下：

package pkg4;

import org.apache.curator.RetryPolicy;
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 Test3 {
    private static int res = 10;

    public static boolean bar() {
        if (res > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + res);
            res--;

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return true;
        } else {
            return false;
        }
    }
    public static void foo() {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 10);

        CuratorFramework zkClient = CuratorFrameworkFactory.builder()
                .connectString("localhost:2181")
                .sessionTimeoutMs(60 * 1000)
                .connectionTimeoutMs(15 * 1000)
                .retryPolicy(retryPolicy)
                .namespace("test1217")
                .build();

        zkClient.start();

        try {
            InterProcessMutex lock = new InterProcessMutex(zkClient,"/myresource");

            while (true) {
                boolean gotLock = false;
                try {
                    gotLock = lock.acquire(3, TimeUnit.SECONDS);
                } catch (Exception e) {
                    gotLock = false;
                }

                if (gotLock) {
                    try {
                        boolean succ = bar();
                        if (!succ) break;

                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    } finally {
                        try {
                            lock.release();
                        } catch (Exception e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        } finally {
            zkClient.close();
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                foo();
            }).start();
        }
    }
}

运行结果如下：

Thread-1 : 10
Thread-0 : 9
Thread-2 : 8
Thread-1 : 7
Thread-0 : 6
Thread-2 : 5
Thread-1 : 4
Thread-0 : 3
Thread-2 : 2
Thread-1 : 1

可以看到3个客户端是严格交替获取锁，这是因为客户端一旦释放锁，其它正在等待的客户端就会立即获取锁，而本客户端再等待锁时，其顺序号是最大的，所以最晚获取锁。

前面用 synchronized 方法时，客户端交替是无序的，因为线程调度是无序的。

特别需要注意的是，3个客户端各自拥有自己的 zkClient 和 lock 实例，客户端之间没有任何关联，这是为了模拟客户端进程之间没有任何关联。客户端各自独立访问Zookeeper。

main() 方法和 bar() 方法都没有变化（ bar() 方法去掉了 synchronized 关键字）。只有 foo() 方法有修改。其实修改也很简单直接，就是在调用 bar() 的前后添加了获取锁和释放锁的操作，只不过加了一些 try...catch...finally ，显得代码多了一些。

此外，在程序运行期间，可以查看 /test1217/myresource 节点，比如：

ls /test1217/myresource
[_c_b6ad09df-597c-418f-bace-619a9a16369d-lock-0000000004, _c_c4a832f5-fb5c-432d-bf8f-bd7010b8571d-lock-0000000003, _c_d0e6779f-9d87-41ad-a66b-4b8eeab18bae-lock-0000000000]

get /test1217/myresource/_c_d0e6779f-9d87-41ad-a66b-4b8eeab18bae-lock-0000000000
127.0.1.1

可见，有3个顺序节点。

程序运行结束后，过一会儿再看，就会报错说 Node does not exist: /test1217/myresource ，可见是临时节点。

注：要想查看节点，最好把sleep时间设置大一些，或者设置断点，否则来不及看。

其它

我在网上看到一些Curator分布式锁的示例代码，比如：

package com.itheima.curator;

import org.apache.curator.RetryPolicy;
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 Ticket12306 implements Runnable{

    private int tickets = 10;//数据库的票数

    private InterProcessMutex lock ;

    public Ticket12306(){
        //重试策略
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 10);
        //2.第二种方式
        //CuratorFrameworkFactory.builder();
        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString("192.168.149.135:2181")
                .sessionTimeoutMs(60 * 1000)
                .connectionTimeoutMs(15 * 1000)
                .retryPolicy(retryPolicy)
                .build();

        //开启连接
        client.start();

        lock = new InterProcessMutex(client,"/lock");
    }

    @Override
    public void run() {
        while(true){
            //获取锁
            try {
                lock.acquire(3, TimeUnit.SECONDS);
                if(tickets > 0){

                    System.out.println(Thread.currentThread()+":"+tickets);
                    Thread.sleep(100);
                    tickets--;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                //释放锁
                try {
                    lock.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

package com.itheima.curator;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.cache.*;
import org.apache.curator.retry.ExponentialBackoffRetry;

public class LockTest {
    public static void main(String[] args) {
        Ticket12306 ticket12306 = new Ticket12306();

        //创建客户端
        Thread t1 = new Thread(ticket12306,"携程");
        Thread t2 = new Thread(ticket12306,"飞猪");

        t1.start();
        t2.start();
    }
}

想法和疑问：

  • 没判断锁是否获取成功。
  • 没有关闭Zookeeper client连接。
  • 多个客户端使用同一个Zookeeper client和lock的实例，没有模拟“分布进程”。
蓝黑2020
关注
Zookeeper 随笔（一）：使用 Curator 框架实现 ZooKeeper 分布式锁
weixin_43870380的博客
10-18 1007
实现分布式锁目前有三种流行方案，分别为基于数据库、Redis、Zookeeper 的方案，我们来看下使用 Zookeeper 如何实现分布式锁
ZooKeeper架构篇 - Curator分布式锁
The Secret
08-18 623
本文分析Curator提供的几种分布式锁。
分布式基础：Curator实现Zookeeper分布式锁
ReturnTmp的博客
07-21 2707
官网的说法curator是一个Java/JVM客户端库，用于zookeeper，一个分布式协调服务。它包括一个高级API框架和实用程序，使ApacheZooKeeper的使用更加简单和可靠。它还包括常见用例和扩展的方法，如服务发现和Java8异步DSL。Curator使用手册-腾讯云开发者社区-腾讯云配置zookeeper集群参考;https。...........................
Curator实现zookeeper分布式锁
一般社员的博客
11-02 213
Curator框架解决分布式锁问题
ZooKeeper ： Curator框架之分布式锁InterProcessSemaphoreMutex
kaven
01-17 842
InterProcessSemaphoreMutex A NON re-entrant mutex that works across JVMs. Uses Zookeeper to hold the lock. All processes in all JVMs that use the same lock path will achieve an inter-process critical section. 跨JVM工作的非可重入互斥锁。使用Zookeeper来持有锁。所有JVM中使用相同锁路径
Zookeeper学习----Curator 框架实现分布式锁案例
https://juejin.cn/user/4248168663101239/posts
07-01 277
Curator 框架实现分布式锁案例一. 自定义ZooKeeper分布式锁存在的问题二. Curator框架的使用①. 添加依赖②. 代码实现③. 测试Curator 分布锁 一. 自定义ZooKeeper分布式锁存在的问题 会话连接是异步的，需要自己去处理。比如使用 CountDownLatch Watch 需要重复注册，不然就不能生效 开发的复杂性还是比较高的 不支持多节点删除和创建。需要自己去递归 二. Curator框架的使用 -Curator 是一个专门解决分布式锁的框架。 ①. 添加依赖
Zookeeper总结——知识点、选举机制、客户端操作及写数据流程、API操作、zookeeper分布式锁之 Curator、ZAB协议、CAP理论之zookeeper的CP理论
weixin_44090845的博客
11-19 2245
Zookeeper一、什么是zookeeper1、zookeeper概述2、zookeeper特点3、zookeeper数据结构4、zookeeper应用场景二、Zookeeper本地安装1、本地模式安装2、配置参数解读三、Zookeeper集群操作1、集群操作1.1集群安装1.2 选举机制（面试重点）1.3 ZK集群启动停止脚本2、客户端命令行操作2.1 命令行基本语法2.2 znode节点数据信息2.3 节点类型 一、什么是zookeeper 1、zookeeper概述 Zookeeper是一个开源的
springboot zookeeper 分布式锁
05-26
SpringBoot结合Zookeeper可以构建高效可靠的分布式锁解决方案，有效地防止羊群效应，即多个客户端同时请求资源导致大量请求涌入，从而影响系统性能。下面我们将深入探讨这个主题。 首先，SpringBoot是一个快速开发...
Redis和Zookeeper分布式锁对比
AttributeSet的博客
08-20 394
1、redis实现 在 JUC 包中除了阻塞锁外还有一种叫 CAS 的无阻塞锁，CAS 操作本身是原子性的，多个线程操作同一个变量的 CAS 时候只有一个线程能进行 CAS 成功，失败的线程接下来那么使用乐观锁机制直接失败要么使用自旋方式使用 CPU 资源重复进行 CAS 尝试。 那么在分布式锁的实现中我们也可以使用类似的方式，比如 Redis 提供了一个保证原子性的 setnx 函数，多个线程调用该函数操作同一个 key 的时候，只有一个线程会返回 OK，其他线程返回 null，那么多个 JVM 中的
Zookeeper 分布式过程.pdf
05-18
接着，通过一个主-从应用的例子，引出了分布式协作的难点，包括如何保证数据的一致性、如何处理节点的故障等。这部分内容为读者提供了一个关于ZooKeeper将要解决的问题的鸟瞰图。 在“第2章了解ZooKeeper”中，作者...
Myabtis源码分析四-缓存模块分析 ，装饰模式的使用(1)
最新发布
2401_83916435的博客
05-01 445
分享一套我整理的面试干货，这份文档结合了我多年的面试官经验，站在面试官的角度来告诉你，面试官提的那些问题他最想听到你给他的回答是什么，分享出来帮助那些对前途感到迷茫的朋友。
基于zookeeper+curator的分布式锁代码实现
suodod的博客
12-13 388
zookeeper的配置和安装请移步zookeeper的安装 分布式锁的可选择性一般常用的为redis的分布式锁和zookeeper的分布式锁,redis是以一个key值作为唯一,zookeeper是以创建的临时节点下的子节点来创建一个唯一,redis分布式锁请移步基于redisson的分布式锁 下面是具体的代码实现 依赖 <dependency> <groupId>org.apache.curator</groupId> <artifac.
Zookeeper开源客户端curator 分布式锁
weixiaohuai的博客
02-02 381
目录 一、概述 二、InterProcessMutex分布式可重入排它锁 三、InterProcessReadWriteLock读写锁 四、总结 一、概述 前面我们已经介绍过zookeeper是分布式锁的实现方案之一，它是利用临时有序节点的特性来保证唯一性的。 Zookeeper分布式锁原理： 获取锁 在zookeeper中，一个分布式锁对应到zookeeper中的一个文件夹，每个客户端线程请求获取分布式锁的时候，就需要在这个文件夹创建一个临时有序节点，有两种情况： 1）、创建的临时顺序节
Zookeeper（curator）实现分布式锁案例
健身变秃，coding变强
11-29 9934
Zookeeper下载安装、Zookeeper常用命令、zookeeper实现分布式锁案例、curator实现分布式案例、zookeeper实现分布式锁思想
【Zookeeper】分布式锁案例（原生、Curator）
See_Star的博客
11-11 1141
Zookeeper分布式锁，原生分布式锁案例，Curator矿建实现分布式锁案例。
Zookeeper分布式锁实现Curator
qq_36864672的博客
02-18 179
当需要加读锁的时候，会去判断自己创建节点的前面有没有写锁，如果没写锁，那么说明前面加的都是读锁，那么读锁就能加锁成功，读读不互斥，如果前面有写锁，那么就加锁失败（自己加的写锁除外），读写互斥。前面说过，判断有没有加锁成功，会返回一个PredicateResults，这里面包含了有没有加锁成功的信息，同时如果没有加锁成功，就会返回需要监听的节点，也就是当前创建的节点的前一个节点。此时如果第二次来加锁，那么就会从threadData中获取到加锁的信息，然后将加锁次数加1，就代表了加锁成功，然后直接返回。
ZooKeeper框架Curator分布式锁实现及源代码分析
稀有气体的技术博客
11-09 6182
本原创入门教程，涵盖ZooKeeper核心内容，通过实例和大量图表，结合实战，帮助学习者理解和运用，任何问题欢迎留言。 目录： zookeeper介绍与核心概念 安装和使用 ZooKeeper分布式锁实现 ZooKeeper框架Curator分布式锁实现及源代码分析 zookeeper 开发实战（java客户端） 上一篇文章中，我们使用zookeeper的java api实现了分布式排...
zookeeper-curator分布式锁实现及源码分析（三）
liujie379908的博客
03-07 455
zookeeper分布式锁实现zookeeper分布式锁实现1.zookeeper-curator实现分布式锁2.源码分析2.1锁的初始化2.2 获取锁2.3 释放锁 zookeeper分布式锁实现 1.zookeeper-curator实现分布式锁 public class DistributedLockDemo { public static void main(String[] ar...
ZooKeeper + Curator 实现分布式锁实例
勇往直前
03-03 491
&lt;dependency&gt; &lt;groupId&gt;org.apache.curator&lt;/groupId&gt; &lt;artifactId&gt;curator-recipes&lt;/artifactId&gt; &lt;version&gt;4.0.0&lt;/version&gt; &lt;/dependency&g
Java(SpringBoot)实战Zookeeper分布式锁
"本文将深入探讨如何在Java（SpringBoot）环境中利用Zookeeper实现分布式锁。文中通过具体的示例代码，详细阐述了整个实现过程，旨在帮助开发者在学习或工作中提升对分布式锁的理解和应用能力。" 在分布式系统中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值