java中zookeeper分布式锁的实现代码

最新推荐文章于 2023-01-19 15:13:17 发布
最新推荐文章于 2023-01-19 15:13:17 发布
阅读量173 收藏 1
点赞数
分类专栏： 分布式 文章标签： java spring 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36993953/article/details/107044419
版权

概念

zk分布式锁，简单一点说就是某个节点尝试创建临时znode，此时创建成功了就获取了这个锁；这个时候别的客户端来创建锁会失败，只能注册个监听器监听这个锁。释放锁就是删除这个znode，一旦释放掉就会通知客户端，然后有一个等待着的客户端就可以再次重新枷锁。

redis和zk分布式比较

redis分布式锁和zk分布式锁的对比：
redis分布式锁，其实需要自己不断去尝试获取锁，比较消耗性能；
zk分布式锁，获取不到锁，注册个监听器即可，不需要不断主动尝试获取锁，性能开销较小。
另外一点就是，如果是redis获取锁的那个客户端bug了或者挂了，那么只能等待超时时间之后才能释放锁；而zk的话，因为创建的是临时znode，只要客户端挂了，znode就没了，此时就自动释放锁。

zk锁直接上代码


import org.apache.zookeeper.*;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.data.Stat;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

import static java.lang.Thread.sleep;


/**
 * 分布式锁的机制
 */
public class DistributedLock implements Lock, Watcher {

    private static final Logger LOGGER = LoggerFactory.getLogger(DistributedLock.class);
    private static final int SESSION_TIMEOUT = 2000*100;
    private String lockName;
    private String root = "/locks";
    private String pathSeperator = "/";
    private String idSeperator = "-";
    private String lockPath;
    private String waitNode;
    private String myNode;
    private CountDownLatch latch;
    private String host;

    protected ZooKeeper zk;
    private CountDownLatch connectedSignal = new CountDownLatch(1);

    public DistributedLock(String host, String lockName) throws IOException, InterruptedException, KeeperException {
        this.host = host;
        zk = new ZooKeeper(host, SESSION_TIMEOUT, this);
        this.lockName = lockName;
        lockPath = root + pathSeperator + lockName;
        connectedSignal.await();
        init();

    }

    private void init() throws InterruptedException, KeeperException {
        try {
            Stat stat = zk.exists(root, false);
            if (stat == null) {
                // 创建根节点
                zk.create(root, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }

        } catch (KeeperException ke) {
            if (KeeperException.Code.NODEEXISTS == ke.code()) {
                LOGGER.info("锁根目录已经创建 {}", root);
            } else {
                throw ke;
            }
        }
        try {
            Stat stat = zk.exists(lockPath, false);
            if (stat == null) {
                // 创建根节点
                zk.create(lockPath, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                LOGGER.info("创建锁节点 {} 成功", lockPath);
            } else {
                LOGGER.info("无需创建锁目录{}", lockPath);
            }
        } catch (KeeperException ke) {
            if (KeeperException.Code.NODEEXISTS == ke.code()) {
                LOGGER.info("无需创建锁目录 {}", lockPath);
            } else {
                throw ke;
            }
        }
    }


    @Override
    public void process(WatchedEvent event) {
        if (event.getState() == Event.KeeperState.SyncConnected) {
            connectedSignal.countDown();
            return;
        }
        if (event.getState() == Event.KeeperState.Expired) {
            try {
                LOGGER.info("zk session 超时，开始重连");
                zk = new ZooKeeper(host, SESSION_TIMEOUT, this);
            } catch (IOException e) {
                LOGGER.error("zk session 超时，重连失败",e);
            }
            return;
        }

        if (event.getType() == Event.EventType.NodeDeleted && this.latch != null) {
            this.latch.countDown();
        }
    }


    @Override
    public void lock() {
        if (tryLock()) {
            return;
        } else {
            waitForLock(-1L, null);
        }
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }


    @Override
    public boolean tryLock() {
        String requiredPath = lockPath + pathSeperator +"lock" + idSeperator;
        try {
            myNode = zk.create(requiredPath, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
            LOGGER.info("创建节点成功{}",myNode);
        } catch (KeeperException | InterruptedException e) {
            LOGGER.error("创建节点异常{}", myNode,e);
            return false;
        }
        return judgeLock();

    }


    @Override
    public void unlock() {
        deleteNode();
        if (zk != null) {
            try {
                zk.close();
            } catch (InterruptedException e) {
                LOGGER.error("关闭连接异常",e);
            }
        }
    }


    @Override
    public Condition newCondition() {
        return null;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        if (this.tryLock()) {
            return true;
        } else {
            return waitForLock(time, unit);
        }

    }


    private boolean doJudgeLock() throws KeeperException, InterruptedException {
        List<String> lockNodes = zk.getChildren(lockPath, false);
        if (lockNodes != null && lockNodes.size() > 0) {
            Collections.sort(lockNodes);
            String nodeName = myNode.substring(myNode.lastIndexOf("/")+1);
            LOGGER.info("判断节点位置，得到当前节点{}", myNode);
            if (lockNodes.indexOf(nodeName) == -1) {
                LOGGER.info("创建后但找不到本节点，网络问题{}", myNode);
                return false;
            } else if (lockNodes.indexOf(nodeName) == 0) {
                LOGGER.info("得到锁{}", myNode);
                return true;
            } else {
                waitNode = lockPath+pathSeperator+lockNodes.get(lockNodes.indexOf(nodeName)-1);
                LOGGER.info("得到前置节点{}", waitNode);
                return false;
            }
        } else {
            LOGGER.info("创建成功过后却得到空列表");
            return false;
        }
    }



    private boolean judgeLock() {
        try {
            return doJudgeLock();
        } catch (KeeperException | InterruptedException e) {
            LOGGER.error("获取分布式锁错误", e);
            return false;
        }
    }


    private boolean waitForLock(Long time, TimeUnit unit) {
        Stat stat;
        try {
            LOGGER.info("查看锁状态{}",waitNode);
            final Watcher previousListener = new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    if (event.getType() == Event.EventType.NodeDeleted) {
                        LOGGER.info("监听到前置节点释放信息{}",waitNode);
                        if(latch != null) {
                            latch.countDown();
                            latch = null;
                        } else {
                            LOGGER.info("未触发latch");
                        }
                    }
                }
            };
            stat = zk.exists(waitNode, previousListener);
        } catch (KeeperException | InterruptedException e) {
            LOGGER.error("等待锁zk错误", e);
            return false;
        }

        if (stat != null) {
            try {
                LOGGER.info("监听锁，等待前置节点{} 事件,", waitNode);
                latch = new CountDownLatch(1);
                long startTime = System.currentTimeMillis();
                if (time > 0) {
                    latch.await(time, unit);
                    long endTime = System.currentTimeMillis();
                    if ((endTime - startTime) > unit.toMillis(time)) {
                        LOGGER.info("等待锁超时 {}", endTime - startTime);
                        deleteNode();
                        return false;
                    } else {
                        return judgeLock();
                    }
                } else {
                    latch.await();
                    return judgeLock();
                }
            } catch (InterruptedException e) {
                LOGGER.error("等待锁过程中异常", e);
                return false;
            }
        } else {
            LOGGER.info("获取前置节点存在信息为null", waitNode);
            return true;
        }
    }

    private void deleteNode() {
        try {
            Stat stat = zk.exists(myNode,false) ;
            if(stat != null) {
                zk.delete(myNode, -1);
                LOGGER.info("删除节点成功{}",myNode);
            }
        } catch (InterruptedException | KeeperException e) {
            LOGGER.error("删除节点异常", e);
        }
    }


    public static void main(String[] args) {

        Thread a = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        DistributedLock lock = null;
                        try {
                        //我的zookeeper地址:192.168.40.204:2181
                            lock = new DistributedLock("192.168.40.204:2181", "testlock");
                            lock.lock();
                            LOGGER.info("a得到锁了，xiumian ");
                            sleep(5000);
                        } catch (IOException e) {
                            LOGGER.error("a获锁失败",e);
                        } catch (InterruptedException e) {
                            LOGGER.error("a获锁失败",e);
                        } catch (KeeperException e) {
                            LOGGER.error("a获锁失败",e);
                        } finally {
                            lock.unlock();
                            LOGGER.info("a释放锁了，xiumian ");
                        }
                    }
                }
        );

        Thread b = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        DistributedLock lock = null;
                        try {
                            lock = new DistributedLock("192.168.40.204:2181", "testlock");
                            lock.lock();
                            sleep(1500);
                            LOGGER.info("b得到锁了");
                        } catch (IOException e) {
                            LOGGER.error("b获锁失败", e);
                        } catch (InterruptedException e) {
                            LOGGER.error("b获锁失败", e);
                        } catch (KeeperException e) {
                            LOGGER.error("b获锁失败", e);
                        } finally {
                            lock.unlock();
                            LOGGER.info("b释放锁了 ");
                        }
                    }
                }
        );

        Thread c = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        DistributedLock lock = null;
                        try {
                            lock = new DistributedLock("192.168.40.204:2181", "testlock");
                            lock.lock();
                            sleep(2000);
                            LOGGER.info("c得到锁了");
                        } catch (IOException e) {
                            LOGGER.error("c获锁失败", e);
                        } catch (InterruptedException e) {
                            LOGGER.error("c获锁失败", e);
                        } catch (KeeperException e) {
                            LOGGER.error("c获锁失败", e);
                        } finally {
                            lock.unlock();
                            LOGGER.info("c释放锁了 ");
                        }
                    }
                }
        );

        Thread d = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        DistributedLock lock = null;
                        try {
                            lock = new DistributedLock("192.168.40.204:2181", "testlock");
                            lock.lock();
                            sleep(2000);
                            LOGGER.info("d得到锁了");
                        } catch (IOException e) {
                            LOGGER.error("d获锁失败", e);
                        } catch (InterruptedException e) {
                            LOGGER.error("d获锁失败", e);
                        } catch (KeeperException e) {
                            LOGGER.error("d获锁失败", e);
                        } finally {
                            lock.unlock();
                            LOGGER.info("d释放锁了 ");
                        }
                    }
                }
        );

        Thread e = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        DistributedLock lock = null;
                        try {
                            lock = new DistributedLock("192.168.40.204:2181", "testlock");
                            lock.lock();
                            sleep(2000);
                            LOGGER.info("e得到锁了");
                        } catch (IOException e) {
                            LOGGER.error("e获锁失败", e);
                        } catch (InterruptedException e) {
                            LOGGER.error("e获锁失败", e);
                        } catch (KeeperException e) {
                            LOGGER.error("e获锁失败", e);
                        } finally {
                            lock.unlock();
                            LOGGER.info("e释放锁了 ");
                        }
                    }
                }
        );
        a.start();
        b.start();
        c.start();
        d.start();
        d.start();

    }

}
松松松松鼠
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用ZooKeeper实现分布式锁
08-14
在分布式高并发的情况下,多个访问之间拥有唯一的一个订单编号,多次提交的订单不会出现重复的,只能是唯一的,ZooKeeper就很好的解决了唯一性
Java Zookeeper实现分布式锁代码
weixin_43290370的博客
08-05 257
JAVA Zookeeper实现分布式可重入锁代码 JAVA Zookeeper实现分布式可重入锁代码 什么是分布式 分布式锁简单理解就是保证分布式服务的共享资源被有序的进行访问和操作, zookeeper分布式锁 由于zookeeper的有序节点是有序的:—>在同一目录下如果同时创建相同的子目录的话会只有一个连接线程创建成功,后边的连接在创建时,ZK 会自动为给定节点名加上一个数字后缀，作为新的节点名,例如: 连接A在目录 / 创建wei , 连接B也在目录 / 创建 wei , 连接A最终创建的节
java架构之路-（分布式zookeeper）zookeeper真实使用场景
xiaocai281的博客
10-11 115
　　上几次博客，我说了一下Zookeeper的简单使用和API的使用，我们接下来看一下他的真实场景。 一、分布式集群管理✨✨✨ 　　我们现在有这样一个需求，请先抛开Zookeeper是集群还是单机的概念，下面提到的都是以Zookeeper集群来说的。 　　　　1. 主动查看线上服务节点 　　　　2. 查看服务节点资源使用情况 　　　　3. 服务离线通知 　　　　4. 服务资源...
使用Java代码实现zookeeper分布式锁
yswKnight的博客
09-05 2633
产生问题 例：在分布式(集群)环境下，每台JVM不能实现同步，比如将一个项目部署到多台tomcat服务器，那么用多台JVM在使用时间戳生成唯一的订单号时，会出现订单号重复问题。 解决办法： 分布式情况下，怎么解决订单号生成不重复: 1. 使用分布式锁 2. 提前生成好，订单号，存放在redis。获取订单号时，直接从redis中取。 实现分布式锁的方式 ...
在Java中操作Zookeeper，使用Zookeeper实现分布式锁
chy1984的博客
05-31 919
目录在java中操作zk依赖连接到zk server检测节点是否存在创建节点删除节点获取子节点列表获取节点数据设置、更新节点数据设置acl权限查看acl权限添加watcher移除监听使用zk实现分布式锁的3种方式   在java中操作zk 依赖 <dependency> <groupId>org.apache.zookeeper</groupId> <artifactId>zookeeper</artifactId>
浅谈Java(SpringBoot)基于zookeeper的分布式锁实现
08-26
主要介绍了Java(SpringBoot)基于zookeeper的分布式锁实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
java分布式锁实现代码
11-24
通过redisson实现分布式锁 通过curator框架实现共享锁，读写锁 项目下载下载，启动本地redis和zookeeper即可； 代码供大家参考，如有不对的地方希望大家指出来。
Java-zookeeper实践代码(分布式锁/注册中心)
11-23
学习时个人编写的样例代码，通过zookeeper实现分布式锁与简单的注册中心
zookeeper分布式锁
02-28
压缩文件中包含两个java文件，采用zookeeper技术实现了分布式锁的机制，同时该分布式锁避免羊群效应（Herd Effect），运行该程序前，本机需要开启zookeeper服务；之后具体操作代码中有介绍；
zookeeper的分布式全局锁纯代码解决方案
03-21
zookeeper的分布式全局锁纯代码解决方案,特点：易上手，可二次开发和封装。
Java学习之Dubbo+ZooKeeper分布式服务Demo
06-19
在之前的一个《Java学习之SpringBoot整合SSM Demo》分享中说到搭建ZooKeeper和Dubbo分布式框架中遇到了一些技术问题没能成功，只分享了其中的一个中间产物，那就是大家看到的《Java学习之SpringBoot整合SSM Demo》分享，带着深深的遗憾父亲节端午节没有回家陪老婆孩子也没有陪岳父岳母在公司苦学JAVA，终于现在解决了这其中的技术难点将ZooKeeper Dubbo框架的搭建工作完成，所以赶紧跟大家写一篇分享，由于只是一个Demo，所以只是写了一个很简单的例子，希望大家不要见笑。
基于zookeeper的分布式锁实现demo
12-27
基于zookeeper的分布式锁实现demo,可以直接用在生产环境
分布式利器Zookeeper（二）:分布式锁
weixin_33734785的博客
05-14 693
在《分布式利器Zookeeper（一）》中对ZK进行了初步的介绍以及搭建ZK集群环境，本篇博客将涉及的话题是：基于原生API方式操作ZK，Watch机制，分布式锁思路探讨等。原生API操作ZK什么叫原生API操作ZK呢？实际上，利用zookeeper.jar这样的就是基于原生的API方式操作ZK，因为这个原生API使用起来并不是让人很舒服，于是出现了zkclient这种方式...
java实现zookeeper分布式锁
qq_51001054的博客
12-05 2197
实现过程： 首先，一个线程获取锁并调用方法生成订单号，在该线程未释放锁资源时，其他线程会被 countDownLatch阻塞，直到该线程释放锁资源。 实现模拟并发生成订单号功能 代码实现： 先导入一个依赖 <dependency> <groupId>com.101tec</groupId> <artifactId>zkclient</artifactId>
如何用Java代码实现zookeeper分布式锁
最新发布
weixin_42581003的博客
01-19 81
可以使用Apache Curator库来实现在Java中使用Zookeeper实现分布式锁。Curator提供了一个InterProcessMutex类来实现分布式锁。 下面是一个简单的示例代码： import org.apache.curator.framework.CuratorFramework; import org.apache.curator.framework.CuratorFram...
java分布式锁代码
weixin_35756637的博客
12-20 151
在 Java 中，可以使用 java.util.concurrent 包中的 ReentrantLock 类来实现分布式锁。 下面是一个示例代码： import java.util.concurrent.locks.ReentrantLock;public class DistributedLock { private static ReentrantLock lock = new Ree...
Zookeeper分布式锁代码实现
南宫文凯
07-19 900
当你知道的越多，你就会明白你的无知。
zokeeper分布式锁代码实现
zxyhj的博客
11-04 264
【Java】zokeeper分布式锁代码实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值