分析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 相关文章推荐
Spring Bean的实例化之属性注入源码剖析过程
Jun 13 Java/Android
Java中使用Filter过滤器的方法
Jun 28 Java/Android
Java 数组内置函数toArray详解
Jun 28 Java/Android
Java基础之this关键字的使用
Jun 30 Java/Android
Java基础-封装和继承
Jul 02 Java/Android
springboot 启动如何排除某些bean的注入
Aug 02 Java/Android
关于springboot配置druid数据源不生效问题(踩坑记)
Sep 25 Java/Android
解析mybatis-plus中的resultMap简单使用
Nov 23 Java/Android
SpringBoot整合阿里云视频点播的过程详解
Dec 06 Java/Android
springboot+zookeeper实现分布式锁
Mar 21 Java/Android
零基础学java之带返回值的方法的定义和调用
Apr 10 Java/Android
SpringBoot使用AOP实现统计全局接口访问次数详解
Jun 16 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计算整个目录大小的方法
2015/06/01 PHP
PHP带节点操作的无限分类实现方法详解
2016/11/09 PHP
Laravel框架实现定时发布任务的方法
2018/08/16 PHP
一个js写的日历(代码部分网摘)
2009/09/20 Javascript
JavaScript 利用StringBuffer类提升+=拼接字符串效率
2009/11/24 Javascript
javascript中的原型链深入理解
2014/02/24 Javascript
JS 实现列表与多选框选择附预览动画
2014/10/29 Javascript
jQuery DOM删除节点操作指南
2015/03/03 Javascript
AngularJS学习笔记之ng-options指令
2015/06/16 Javascript
JavaScript字符串删除重复字符的方法
2015/12/25 Javascript
React.js入门实例教程之创建hello world 的5种方式
2016/05/11 Javascript
基于jQuery实现仿QQ空间送礼物功能代码
2016/05/24 Javascript
JavaScript动态添加事件之事件委托
2016/07/12 Javascript
JavaScript 数组的进化与性能分析
2017/09/18 Javascript
微信小程序自定义组件实现tabs选项卡功能
2018/07/14 Javascript
实例介绍JavaScript中多种组合继承
2019/01/20 Javascript
浅谈express.js框架中间件(middleware)
2019/04/07 Javascript
[01:34]DOTA2 7.22版本新增神杖效果一览(敏捷英雄篇)
2019/05/28 DOTA
python的常见命令注入威胁
2013/02/18 Python
Python实现类似jQuery使用中的链式调用的示例
2016/06/16 Python
浅谈编码,解码,乱码的问题
2016/12/30 Python
Python实现采用进度条实时显示处理进度的方法
2017/12/19 Python
GitHub 热门:Python 算法大全,Star 超过 2 万
2019/04/29 Python
django 使用全局搜索功能的实例详解
2019/07/18 Python
python 并发编程 多路复用IO模型详解
2019/08/20 Python
python根据时间获取周数代码实例
2019/09/30 Python
Python3 Tkinkter + SQLite实现登录和注册界面
2019/11/19 Python
10个Python面试常问的问题(小结)
2019/11/20 Python
pytorch中的自定义反向传播,求导实例
2020/01/06 Python
微软马来西亚官方网站:Microsoft马来西亚
2019/11/22 全球购物
小学生元旦广播稿
2014/02/21 职场文书
教师节促销方案
2014/03/22 职场文书
小学作文评语大全
2014/04/21 职场文书
领导干部作风整顿个人剖析材料
2014/10/11 职场文书
2014年妇联工作总结
2014/11/21 职场文书
nginx location 带斜杠【 / 】与不带的区别
2022/04/13 Servers