分析ZooKeeper分布式锁的实现


Posted in Java/Android onJune 30, 2021
目录
  • 一、分布式锁方案比较
  • 二、ZooKeeper实现分布式锁
    • 2.1、方案一
    • 2.2、方案二

一、分布式锁方案比较

方案 实现思路 优点 缺点
利用 MySQL 的实现方案 利用数据库自身提供的锁机制实现,要求数据库支持行级锁 实现简单 性能差,无法适应高并发场景;容易出现死锁的情况;无法优雅的实现阻塞式锁
利用 Redis 的实现方案 使用 Setnx 和 lua 脚本机制实现,保证对缓存操作序列的原子性 性能好 实现相对复杂,有可能出现死锁;无法优雅的实现阻塞式锁
利用 ZooKeeper 的实现方案 基于 ZooKeeper 节点特性及 watch 机制实现 性能好,稳定可靠性高,能较好地实现阻塞式锁 实现相对复杂

二、ZooKeeper实现分布式锁

这里使用 ZooKeeper 来实现分布式锁,以50个并发请求来获取订单编号为例,描述两种方案,第一种为基础实现,第二种在第一种基础上进行了优化。

2.1、方案一

流程描述:

分析ZooKeeper分布式锁的实现

具体代码:

OrderNumGenerator:

/**
 * @Description 生成随机订单号
 */
public class OrderNumGenerator {

    private static long count = 0;

    /**
     * 使用日期加数值拼接成订单号
     */
    public String getOrderNumber() throws Exception {
        String date = DateTimeFormatter.ofPattern("yyyyMMddHHmmss").format(LocalDateTime.now());
        String number = new DecimalFormat("000000").format(count++);
        return date + number;
    }
}

Lock:

/**
 * @Description 自定义锁接口
 */
public interface Lock {

    /**
     * 获取锁
     */
    public void getLock();

    /**
     * 释放锁
     */
    public void unLock();
}

AbstractLock:

/**
 * @Description 定义一个模板,具体的方法由子类来实现
 */
public abstract class AbstractLock implements Lock {

    /**
     * 获取锁
     */
    @Override
    public void getLock() {

        if (tryLock()) {
            System.out.println("--------获取到了自定义Lock锁的资源--------");
        } else {
            // 没拿到锁则阻塞,等待拿锁
            waitLock();
            getLock();
        }

    }

    /**
     * 尝试获取锁,如果拿到了锁返回true,没有拿到则返回false
     */
    public abstract boolean tryLock();

    /**
     * 阻塞,等待获取锁
     */
    public abstract void waitLock();
}

ZooKeeperAbstractLock:

/**
 * @Description 定义需要的服务连接
 */
public abstract class ZooKeeperAbstractLock extends AbstractLock {

    private static final String SERVER_ADDR = "192.168.182.130:2181,192.168.182.131:2181,192.168.182.132:2181";

    protected ZkClient zkClient = new ZkClient(SERVER_ADDR);

    protected static final String PATH = "/lock";
}

ZooKeeperDistrbuteLock:

/**
 * @Description 真正实现锁的细节
 */
public class ZooKeeperDistrbuteLock extends ZooKeeperAbstractLock {
    private CountDownLatch countDownLatch = null;

    /**
     * 尝试拿锁
     */
    @Override
    public boolean tryLock() {
        try {
            // 创建临时节点
            zkClient.createEphemeral(PATH);
            return true;
        } catch (Exception e) {
            // 创建失败报异常
            return false;
        }
    }

    /**
     * 阻塞,等待获取锁
     */
    @Override
    public void waitLock() {
        // 创建监听
        IZkDataListener iZkDataListener = new IZkDataListener() {
            @Override
            public void handleDataChange(String s, Object o) throws Exception {

            }

            @Override
            public void handleDataDeleted(String s) throws Exception {
                // 释放锁,删除节点时唤醒等待的线程
                if (countDownLatch != null) {
                    countDownLatch.countDown();
                }
            }
        };

        // 注册监听
        zkClient.subscribeDataChanges(PATH, iZkDataListener);

        // 节点存在时,等待节点删除唤醒
        if (zkClient.exists(PATH)) {
            countDownLatch = new CountDownLatch(1);
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 删除监听
        zkClient.unsubscribeDataChanges(PATH, iZkDataListener);
    }

    /**
     * 释放锁
     */
    @Override
    public void unLock() {
        if (zkClient != null) {
            System.out.println("释放锁资源");
            zkClient.delete(PATH);
            zkClient.close();
        }
    }
}

测试效果:使用50个线程来并发测试ZooKeeper实现的分布式锁

/**
 * @Description 使用50个线程来并发测试ZooKeeper实现的分布式锁
 */
public class OrderService {

    private static class OrderNumGeneratorService implements Runnable {

        private OrderNumGenerator orderNumGenerator = new OrderNumGenerator();;
        private Lock lock = new ZooKeeperDistrbuteLock();

        @Override
        public void run() {
            lock.getLock();
            try {
                System.out.println(Thread.currentThread().getName() + ", 生成订单编号:"  + orderNumGenerator.getOrderNumber());
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unLock();
            }
        }
    }

    public static void main(String[] args) {
        System.out.println("----------生成唯一订单号----------");
        for (int i = 0; i < 50; i++) {
            new Thread(new OrderNumGeneratorService()).start();
        }
    }
}

2.2、方案二

方案二在方案一的基础上进行优化,避免产生“羊群效应”,方案一一旦临时节点删除,释放锁,那么其他在监听这个节点变化的线程,就会去竞争锁,同时访问 ZooKeeper,那么怎么更好的避免各线程的竞争现象呢,就是使用临时顺序节点,临时顺序节点排序,每个临时顺序节点只监听它本身的前一个节点变化。

流程描述:

分析ZooKeeper分布式锁的实现

具体代码

具体只需要将方案一中的 ZooKeeperDistrbuteLock 改变,增加一个 ZooKeeperDistrbuteLock2,测试代码中使用 ZooKeeperDistrbuteLock2 即可测试,其他代码都不需要改变。

/**
 * @Description 真正实现锁的细节
 */
public class ZooKeeperDistrbuteLock2 extends ZooKeeperAbstractLock {

    private CountDownLatch countDownLatch = null;
    /**
     * 当前请求节点的前一个节点
     */
    private String beforePath;
    /**
     * 当前请求的节点
     */
    private String currentPath;

    public ZooKeeperDistrbuteLock2() {
        if (!zkClient.exists(PATH)) {
            // 创建持久节点,保存临时顺序节点
            zkClient.createPersistent(PATH);
        }
    }

    @Override
    public boolean tryLock() {
        // 如果currentPath为空则为第一次尝试拿锁,第一次拿锁赋值currentPath
        if (currentPath == null || currentPath.length() == 0) {
            // 在指定的持久节点下创建临时顺序节点
            currentPath = zkClient.createEphemeralSequential(PATH + "/", "lock");
        }
        // 获取所有临时节点并排序,例如:000044
        List<String> childrenList = zkClient.getChildren(PATH);
        Collections.sort(childrenList);

        if (currentPath.equals(PATH + "/" + childrenList.get(0))) {
            // 如果当前节点在所有节点中排名第一则获取锁成功
            return true;
        } else {
            int wz = Collections.binarySearch(childrenList, currentPath.substring(6));
            beforePath = PATH + "/" + childrenList.get(wz - 1);
        }
        return false;
    }

    @Override
    public void waitLock() {
        // 创建监听
        IZkDataListener iZkDataListener = new IZkDataListener() {
            @Override
            public void handleDataChange(String s, Object o) throws Exception {

            }

            @Override
            public void handleDataDeleted(String s) throws Exception {
                // 释放锁,删除节点时唤醒等待的线程
                if (countDownLatch != null) {
                    countDownLatch.countDown();
                }
            }
        };

        // 注册监听,这里是给排在当前节点前面的节点增加(删除数据的)监听,本质是启动另外一个线程去监听前置节点
        zkClient.subscribeDataChanges(beforePath, iZkDataListener);

        // 前置节点存在时,等待前置节点删除唤醒
        if (zkClient.exists(beforePath)) {
            countDownLatch = new CountDownLatch(1);
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 删除对前置节点的监听
        zkClient.unsubscribeDataChanges(beforePath, iZkDataListener);
    }

    /**
     * 释放锁
     */
    @Override
    public void unLock() {
        if (zkClient != null) {
            System.out.println("释放锁资源");
            zkClient.delete(currentPath);
            zkClient.close();
        }
    }
}

以上就是分析ZooKeeper分布式锁的实现的详细内容,更多关于ZooKeeper分布式锁的资料请关注三水点靠木其它相关文章!

Java/Android 相关文章推荐
浅析NIO系列之TCP
Jun 15 Java/Android
详解Java实践之抽象工厂模式
Jun 18 Java/Android
Netty结合Protobuf进行编解码的方法
Jun 26 Java/Android
Java实现二维数组和稀疏数组之间的转换
Jun 27 Java/Android
Android开发实现极为简单的QQ登录页面
Apr 24 Java/Android
Spring Boot 使用 Spring-Retry 进行重试框架
Apr 24 Java/Android
Android Studio实现带三角函数对数运算功能的高级计算器
May 20 Java/Android
利用正则表达式匹配浮点型数据
May 30 Java/Android
Java异常体系非正常停止和分类
Jun 14 Java/Android
java中如何截取字符串最后一位
Jul 07 Java/Android
MyBatis在注解上使用动态SQL方式(@select使用if)
Jul 07 Java/Android
SpringBoot详解自定义Stater的应用
Jul 15 Java/Android
Java并发编程必备之Future机制
详解Spring Boot使用系统参数表提升系统的灵活性
Jun 30 #Java/Android
浅谈resultMap的用法及关联结果集映射
Spring中bean的生命周期之getSingleton方法
每日六道java新手入门面试题,通往自由的道路
Jun 30 #Java/Android
mybatis 解决从列名到属性名的自动映射失败问题
Jun 30 #Java/Android
Java基础之this关键字的使用
Jun 30 #Java/Android
You might like
用PHP实现Ftp用户的在线管理的代码
2007/03/06 PHP
PHP实现防止表单重复提交功能【基于token验证】
2018/05/24 PHP
javascript parseInt 函数分析(转)
2009/03/21 Javascript
getElementByIdx_x js自定义getElementById函数
2012/01/24 Javascript
css配合jquery美化 select
2013/11/29 Javascript
悬浮数字的实现案例
2014/02/19 Javascript
JS中判断null、undefined与NaN的方法
2014/03/26 Javascript
jQuery中对未来的元素绑定事件用bind、live or on
2014/04/17 Javascript
2014 年最热门的21款JavaScript框架推荐
2014/12/25 Javascript
javascript属性访问表达式用法分析
2015/04/25 Javascript
javascript实现表格增删改操作实例详解
2015/05/15 Javascript
jQuery实现的手机发送验证码倒计时效果代码分享
2015/08/24 Javascript
JavaScript在网页中画圆的函数arc使用方法
2015/11/13 Javascript
解决低版本的浏览器不支持es6的import问题
2018/03/09 Javascript
mpvue小程序仿qq左滑置顶删除组件
2018/08/03 Javascript
Nuxt配合Node在实际生产中的应用详解
2018/08/07 Javascript
详解React中合并单元格的正确写法
2019/01/08 Javascript
jQuery高级编程之js对象、json与ajax用法实例分析
2019/11/01 jQuery
公众号SVG动画交互实战代码
2020/05/31 Javascript
[03:07]完美世界DOTA2联赛PWL DAY10 决赛集锦
2020/11/11 DOTA
Python中使用wxPython开发的一个简易笔记本程序实例
2015/02/08 Python
Python读写unicode文件的方法
2015/07/10 Python
python安装twisted的问题解析
2018/08/21 Python
python消费kafka数据批量插入到es的方法
2018/12/27 Python
python中时间模块的基本使用教程
2019/05/14 Python
利用python实现周期财务统计可视化
2019/08/25 Python
python误差棒图errorbar()函数实例解析
2020/02/11 Python
Python中格式化字符串的四种实现
2020/05/26 Python
Python TestSuite生成测试报告过程解析
2020/07/23 Python
CSS3实现头像旋转效果
2017/03/13 HTML / CSS
护士岗前培训自我评鉴
2014/02/28 职场文书
大学生职业生涯规划书
2014/03/14 职场文书
幼儿园教师岗位职责
2014/03/17 职场文书
校长新学期致辞
2015/07/30 职场文书
社区结对共建协议书
2016/03/23 职场文书
Golang中channel的原理解读(推荐)
2021/10/16 Golang