分析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 相关文章推荐
springboot中一些比较常用的注解总结
Jun 11 Java/Android
Feign调用全局异常处理解决方案
Jun 24 Java/Android
SpringBoot读取Resource下文件的4种方法
Jul 02 Java/Android
Java使用jmeter进行压力测试
Jul 09 Java/Android
logback 实现给变量指定默认值
Aug 30 Java/Android
java中用float时,数字后面加f,这样是为什么你知道吗
Sep 04 Java/Android
springmvc直接不经过controller访问WEB-INF中的页面问题
Feb 24 Java/Android
JavaWeb实现显示mysql数据库数据
Mar 19 Java/Android
Netty客户端接入流程NioSocketChannel创建解析
Mar 25 Java/Android
Java中的继承、多态以及封装
Apr 11 Java/Android
详解Android中的TimePickerView(时间选择器)的用法
Apr 30 Java/Android
MyBatis在注解上使用动态SQL方式(@select使用if)
Jul 07 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中$_FILES的使用以及注意事项
2013/07/05 PHP
php实现微信公众平台发红包功能
2018/06/14 PHP
php使用curl模拟浏览器表单上传文件或者图片的方法
2018/11/10 PHP
TNC vs BOOM BO3 第二场2.13
2021/03/10 DOTA
基于jQuery的试卷自动排版系统实现代码
2011/01/06 Javascript
js遍历、动态的添加数据的小例子
2013/06/22 Javascript
js实现的GridView即表头固定表体有滚动条且可滚动
2014/02/19 Javascript
jquery动态更换设置背景图的方法
2014/03/25 Javascript
javascript实现动态统计图开发实例
2015/11/21 Javascript
JavaScript希尔排序、快速排序、归并排序算法
2016/05/08 Javascript
js实现固定宽高滑动轮播图效果
2017/01/13 Javascript
对象不支持indexOf属性或方法的解决方法(必看)
2017/05/28 Javascript
详解vue数据渲染出现闪烁问题
2017/06/29 Javascript
深入浅析ES6 Class 中的 super 关键字
2017/10/20 Javascript
angular4实现tab栏切换的方法示例
2017/10/21 Javascript
详解Webpack实战之构建 Electron 应用
2017/12/25 Javascript
在vue项目中安装使用Mint-UI的方法
2017/12/27 Javascript
vue element-ui table表格滚动加载方法
2018/03/02 Javascript
详解Vue取消eslint语法限制
2018/08/04 Javascript
JS数组push、unshift、pop、shift方法的实现与使用方法示例
2020/04/29 Javascript
kNN算法python实现和简单数字识别的方法
2014/11/18 Python
python操作ssh实现服务器日志下载的方法
2015/06/03 Python
Python二叉搜索树与双向链表转换实现方法
2016/04/29 Python
详解常用查找数据结构及算法(Python实现)
2016/12/09 Python
Python爬虫代理IP池实现方法
2017/01/05 Python
Python网络编程之TCP套接字简单用法示例
2018/04/09 Python
python3+PyQt5实现自定义流体混合窗口部件
2018/04/24 Python
浅谈Python接口对json串的处理方法
2018/12/19 Python
python面向对象 反射原理解析
2019/08/12 Python
python实现输入的数据在地图上生成热力图效果
2019/12/06 Python
html5仿支付宝密码框的实现代码
2017/09/06 HTML / CSS
大跃进口号
2014/06/16 职场文书
甜品店创业计划书
2014/09/21 职场文书
干部年终考核评语
2015/01/04 职场文书
导游词之绍兴柯岩古镇
2020/01/09 职场文书
详解Go语言中配置文件使用与日志配置
2022/06/01 Golang