分布式锁的实现

最新推荐文章于 2024-07-22 09:53:56 发布
最新推荐文章于 2024-07-22 09:53:56 发布
阅读量483 收藏
点赞数 1
分类专栏： 分布式 文章标签： zookeeper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maoyeqiu/article/details/72782730
版权

zookeeper的基础知识

zookeeper原理（转）

zookeeper client使用笔记

Zookeeper实现分布式锁

分布式服务框架 Zookeeper -- 管理分布式环境中的数据

分布式锁的几种实现方式~

Java分布式锁三种实现方案

基于zookeeper的分布锁的实现，存在羊群效应

public class SDistributeLock {

    private  String lockZnode = null;

    private String lockNameSpace = "/mylock";

    private String nodeString = lockNameSpace + "/test1";

    private static ZooKeeper zk;

    private static String zooKeeperUrl="localhost:2181,localhost:2182,localhost:2183";

    static {
        CountDownLatch connectorSemaphore = new CountDownLatch(1);
        String url = zooKeeperUrl;
        int timeout = 60000;
        try {
            zk = new ZooKeeper(url, timeout, new ConnectWatcher(connectorSemaphore));
            System.out.println("++++++++++++++++++"+zk.getState());
            connectorSemaphore.await();
            System.out.println("++++++++++++++++++"+zk.getState());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void ensureRootPath() throws InterruptedException {
        try {
            if (zk.exists(lockNameSpace,true)==null){
                zk.create(lockNameSpace,"".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

    private void watchNode(final String nodeString, final Thread thread) throws InterruptedException {
        try {
            zk.exists(nodeString, new Watcher() {
                @Override
                public void process(WatchedEvent watchedEvent) {
                    System.out.println("out  "+thread.getName()+"==" + watchedEvent.toString());
                    if(watchedEvent.getType() == Event.EventType.NodeDeleted){
                        System.out.println("外部  "+thread.getName()+"==" + "进入中断");
                        thread.interrupt();
                    }
                    try {
                        zk.exists(nodeString,new Watcher() {
                            @Override
                            public void process(WatchedEvent watchedEvent) {
                                System.out.println("in  "+thread.getName()+ "==" + watchedEvent.toString());
                                if(watchedEvent.getType() == Event.EventType.NodeDeleted){
                                    System.out.println("内部  "+thread.getName()+"==" + "进入中断");
                                    thread.interrupt();
                                }
                                try {
                                    zk.exists(nodeString,true);
                                } catch (KeeperException e) {
                                    e.printStackTrace();
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                            }

                        });
                    } catch (KeeperException e) {
                        e.printStackTrace();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            });
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取锁
     * @return
     * @throws InterruptedException
     */
    public boolean lock() throws InterruptedException {
        String path = null;
        ensureRootPath();
        watchNode(nodeString,Thread.currentThread());
        while (true) {
            try {
                path = zk.create(nodeString, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
            } catch (KeeperException e) {
                System.out.println(Thread.currentThread().getName() + "  getting Lock but can not get");
                try {
                    Thread.sleep(5000);
                }catch (InterruptedException ex){
                    System.out.println("thread is notify");
                }
            }
            if (!Strings.nullToEmpty(path).trim().isEmpty()) {
                System.out.println(Thread.currentThread().getName() + "  get Lock...");
                return true;
            }
        }
    }

    /**
     * 释放锁
     */
    public void unlock(){
        try {
            zk.delete(nodeString,-1);
            System.out.println(Thread.currentThread().getName() + " release Lock...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

}

测试类 

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class LockTest {

    @Test
    public void testDistributeLock(){
        ExecutorService executor = Executors.newCachedThreadPool();
        final int count = 1000;
        //在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
        final CountDownLatch latch = new CountDownLatch(count);
        for (int i = 0; i < count; i++) {
            final DistributeLock node = new DistributeLock();
            executor.submit(new Runnable() {
                public void run() {
                    try {
                        //如果不加CountDownLatch，睡1s会直接让主线程跑完shutdown而没有加锁，
                        // 这里睡1000秒可以让多个线程同时执行
                        Thread.sleep(1000);
                        node.lock(); // 阻塞获取锁
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        latch.countDown();
                        node.unlock();
                    }
                }
            });
        }

       try {
            //await方法调用此方法会一直阻塞当前线程，直到计时器的值为0
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        executor.shutdown();
    }
}

执行结果

pool-3-thread-5  get Lock...
pool-3-thread-2  getting Lock but can not get
pool-3-thread-3  getting Lock but can not get
pool-3-thread-1  getting Lock but can not get
pool-3-thread-4  getting Lock but can not get
out  pool-3-thread-2==WatchedEvent state:SyncConnected type:NodeCreated path:/mylock/test1
out  pool-3-thread-1==WatchedEvent state:SyncConnected type:NodeCreated path:/mylock/test1
out  pool-3-thread-5==WatchedEvent state:SyncConnected type:NodeCreated path:/mylock/test1
in  pool-3-thread-2==WatchedEvent state:SyncConnected type:NodeDeleted path:/mylock/test1
内部  pool-3-thread-2==进入中断
thread is notify
pool-3-thread-5 release Lock...
in  pool-3-thread-1==WatchedEvent state:SyncConnected type:NodeDeleted path:/mylock/test1
内部  pool-3-thread-1==进入中断
thread is notify
pool-3-thread-2  get Lock...
out  pool-3-thread-4==WatchedEvent state:SyncConnected type:NodeDeleted path:/mylock/test1
外部  pool-3-thread-4==进入中断
thread is notify
pool-3-thread-1  getting Lock but can not get
in  pool-3-thread-3==WatchedEvent state:SyncConnected type:NodeDeleted path:/mylock/test1
内部  pool-3-thread-3==进入中断
thread is notify
pool-3-thread-4  getting Lock but can not get
in  pool-3-thread-5==WatchedEvent state:SyncConnected type:NodeDeleted path:/mylock/test1
内部  pool-3-thread-5==进入中断
pool-3-thread-3  getting Lock but can not get
in  pool-3-thread-4==WatchedEvent state:SyncConnected type:NodeDeleted path:/mylock/test1
内部  pool-3-thread-4==进入中断
pool-3-thread-2 release Lock...
thread is notify
pool-3-thread-4  get Lock...
pool-3-thread-4 release Lock...
pool-3-thread-1  get Lock...
pool-3-thread-3  getting Lock but can not get
pool-3-thread-1 release Lock...
pool-3-thread-3  get Lock...

解决羊群效应：

public class DistributeLock {

    private  String lockZnode = null;

    private static ZooKeeper zk;

    private static String zooKeeperUrl="localhost:2181,localhost:2182,localhost:2183";

    static {
        CountDownLatch connectorSemaphore = new CountDownLatch(1);
        String url = zooKeeperUrl;
        int timeout = 60000;
        try {
            zk = new ZooKeeper(url, timeout, new ConnectWatcher(connectorSemaphore));
            System.out.println("++++++++++++++++++"+zk.getState());
            connectorSemaphore.await();
            System.out.println("++++++++++++++++++"+zk.getState());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取锁
     * @return
     * @throws InterruptedException
     */
    public void lock(){
        try {
            Stat stat = zk.exists("/locknode", false);//此去不执行 Watcher
            if(stat == null){
                //创建根节点，永久存在
                zk.create("/locknode", "lock".getBytes(),
                        ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
            String path = zk.create("/locknode/guid-lock","lock".getBytes(),
                    ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
            lockZnode=path;
            List<String> children = zk.getChildren("/locknode", true);
            Collections.sort(children);
            if (!Strings.nullToEmpty(path).trim().isEmpty()
                    &&!Strings.nullToEmpty(children.get(0)).trim().isEmpty()
                    &&path.equals("/locknode/"+children.get(0))) {
                System.out.println(Thread.currentThread().getName() + "  get Lock...");
                return;
            }
            String watchNode = null;
            for (int i=children.size()-1;i>=0;i--){
                if(children.get(i).compareTo(path.substring(path.lastIndexOf("/") + 1))<0){
                    watchNode = children.get(i);
                    break;
                }
            }

            if (watchNode!=null){
                final String watchNodeTmp = watchNode;
                //给当前线程的创建的znode小的znode添加监听，当发生删除事件的时候只叫醒当前的这个线程
                final Thread thread = Thread.currentThread();
                Stat stat1 = zk.exists("/locknode/"  + watchNodeTmp,new Watcher() {
                    @Override
                    public void process(WatchedEvent watchedEvent) {
                        if(watchedEvent.getType() == Watcher.Event.EventType.NodeDeleted){
                            thread.interrupt();
                        }
                        try {
                            zk.exists("/locknode/" + watchNodeTmp,true);
                        } catch (KeeperException e) {
                            e.printStackTrace();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                });
                if(stat1 != null){
                    System.out.println("Thread " + Thread.currentThread().getId() + " waiting for " + "/locknode/" + watchNode);
                }
            }
            try {
                //等待直到被唤醒
                Thread.sleep(1000000000);
            }catch (InterruptedException ex){
                System.out.println(Thread.currentThread().getName() + " notify");
                System.out.println(Thread.currentThread().getName() + "  get Lock...");
                return;
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 释放锁
     */
    public void unlock(){
        try {
            System.out.println(Thread.currentThread().getName() +  "release Lock...");
            zk.delete(lockZnode,-1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

}


源码地址 


利用zookeeper部署了一个最小的虚拟集群，有3个zookeeper服务器，三个服务器使用的是同一个IP但是不同的端口，写了一个服务多次请求这个集群可以清楚的看到，多次请求分别到了不同的zookeeper服务器上。
但是利用zookeeper1的端口去get znode的时候，不管这个znode是在哪个zookeeper服务器下创建的都可以获取到，说明整个zookeeper集群维护的是同一个文件结构
另外在创建节点的时候必须是CreateMode.PERSISTENT_SEQUENTIAL持久化类型的，否则在使用命令获取节点的时候是获取不到的，EPHEMERAL这种类型的数据是停止服务后无法获取的，请求的服务关闭时临时的值也会消失
将APP1的所有配置配置到/APP1 znode下，APP1所有机器一启动就对/APP1这个节点进行监控(zk.exist("/APP1",true)),并且实现回调方法Watcher，那么在zookeeper上/APP1 znode节点下数据发生变化的时候，每个机器都会收到通知，Watcher方法将会被执行，那么应用再取下数据即可(zk.getData("/APP1",false,null));
一个leader，多个follower
每个server保存一份数据副本
全局数据一致
分布式读写
ZooKeeper拥有一个层次的命名空间，这个和分布式的文件系统非常相似。不同的是ZooKeeper命名空间中的Znode，兼具文件和目录两种特点。既像文件一样维护着数据、元信息、ACL、时间戳等数据结构，又像目录一样可以作为路径标识的一部分，并可以具有子znode。用户对znode具有增、删、改、查等操作
ZooKeeper目录树中每一个节点对应一个Znode。每个Znode维护着一个属性结构，它包含着版本号(dataVersion)，时间戳(ctime,mtime)等状态信息。ZooKeeper正是使用节点的这些特性来实现它的某些特定功能。每当Znode的数据改变时，他相应的版本号将会增加。每当客户端检索数据时，它将同时检索数据的版本号。并且如果一个客户端执行了某个节点的更新或删除操作，他也必须提供要被操作的数据版本号。如果所提供的数据版本号与实际不匹配，那么这个操作将会失败。
ooKeeper允许各分布式进程通过一个共享的命名空间相互联系，该命名空间类似于一个标准的层次型的文件系统：由若干注册了的数据节点构成(用Zookeeper的术语叫znode)，这些节点类似于文件和目录。
客户端可以在节点上设置watch(我们称之为监视器)。当节点状态发生改变时(数据的增、删、改)将会触发watch所对应的操作。当watch被触发时，ZooKeeper将会向客户端发送且仅发送一条通知，因为watch只能被触发一次。

ZK集群搭建

利用zookeeper部署了一个最小的虚拟集群，有3个zookeeper服务器，三个服务器使用的是同一个IP但是不同的端口，写了一个服务多次请求这个集群可以清楚的看到，多次请求分别到了不同的zookeeper服务器上。

但是利用zookeeper1的端口去get znode的时候，不管这个znode是在哪个zookeeper服务器下创建的都可以获取到，说明整个zookeeper集群维护的是同一个文件结构，每个zk节点的数据都是一致的

另外在创建节点的时候必须是CreateMode.PERSISTENT_SEQUENTIAL持久化类型的，否则在使用命令获取节点的时候是获取不到的，EPHEMERAL这种类型的数据是停止服务后无法获取的，请求的服务关闭时临时的值也会消失

txxs
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分布式锁实现（基于redis-mysql）1
08-03
本文主要探讨了三种常见的分布式锁实现方式，包括基于Redis、MySQL以及Zookeeper的实现方法。 **基于Redis实现分布式锁** Redis是一个内存数据库，其命令执行是单线程的，这使得它非常适合用来实现分布式锁。Redis...
基于Redis实现分布式锁之前，这些坑你一定得知道
阿里本地生活技术团队
03-10 3762
作者简介 陈寒立，一个不误正业的程序员。先后在物流金融组、物流末端业务组和压力平衡组打过杂，技术栈从Python玩到了Java，依然没学会好好写业务代码，梦想着用抽象的模型拯救业务于水火之中。 开头 基于Redis的分布式锁对大家来说并不陌生，可是你的分布式锁有失败的时候吗？在失败的时候可曾怀疑过你在用的分布式锁真的靠谱吗？以下是结合自己的踩坑经验总结的一些经验之谈。 你真的需要分布式锁吗? ...
isrun java用法_Java多线程问题--方法isFair()、isHeldByCurrentThread()和isLocked()的用法和区别...
weixin_42134234的博客
02-17 651
本文内容部分引自《Java多线程编程核心技术》，感谢作者！！！代码地址：https://github.com/xianzhixianzhixian/thread.git方法isFair()、isHeldByCurrentThread()和isLocked()的用法和区别1、lock.isFair()方法用来判断lock锁是公平锁还是非公平锁。公平锁是指，线程获得锁的顺序是按其等待锁的先后顺序来的，...
redisTemplate封装成redisUtils和分布式锁实现
06-18
以下是一个简单的分布式锁实现： ```java public class DistributedLock { private static final String LOCK_PREFIX = "lock:"; public boolean lock(String lockKey, long waitTime, long leaseTime) { ...
Redis分布式锁实现方式及超时问题解决
08-19
Redis分布式锁实现方式及超时问题解决 本文主要介绍了Redis分布式锁实现方式及超时问题解决，通过详细的示例代码和实现原理，帮助读者理解分布式锁的应用场景和实现方式，并解决分布式锁常见的问题。 一、分布式锁...
使用MySQL实现一个分布式锁
09-08
MySQL作为一种常用的数据库系统，可以被用来实现分布式锁，因为其提供了原子性操作，能够确保在高并发场景下的数据一致性。 在MySQL中实现分布式锁的基本思路是利用数据库的事务特性以及唯一索引来保证锁的获取与...
单机redis分布式锁实现原理解析
08-19
单机Redis分布式锁实现原理解析 单机Redis分布式锁是指在单机环境下使用Redis实现分布式锁的机制。分布式锁是指在分布式系统中，多个节点之间需要互斥访问共享资源时使用的锁机制。单机Redis分布式锁的实现原理是...
zookeeper+kafka消息队列群集部署
wkysdhr的博客
07-16 852
消息(Message)是指在应用间传送的数据。消息可以非常简单，比如只包含文本字符串，也可以更复杂，可能包含嵌入对象。消息队列(Message Queue)是一种应用间的通信方式，消息发送后可以立即返回，由消息系统来确保消息的可靠传递。消息发布者只管把消息发布到MQ 中而不用管谁来取，消息使用者只管从MQ中取消息而不管是谁发布的。这样发布者和使用者都不用知道对方的存在。
以Zookeeper为例 浅谈脑裂与奇数节点问题
datacreating的博客
07-19 994
因此，对于6台服务器的集群，计算过半数需要的票数为 `half = 6 / 2 = 3`，意味着至少需要4票来成功选举出一个Leader。在某些情况下，为了确保集群中只有一个有效的领导者，可以采用磁盘锁或仲裁机制。② 若网络断开，机房1内的3台服务器可以通过内部投票选出一个Leader（因为3票已经超过了5台总数的半数，即2.5向上取整为3），而机房2因只有2台服务器，无法独立选举出Leader。此外，资源的浪费也是脑裂的一个重要影响，因为同一操作可能在多个分区中重复执行，消耗大量计算和存储资源。
分布式锁的实现：Redis和Zookeeper
weixin_53840353的博客
07-22 443
在分布式系统中，确保数据的一致性和避免并发问题是非常重要的。分布式锁是解决这些问题的关键技术之一。本文将详细介绍如何使用Redis和Zookeeper实现分布式锁，并通过Java代码示例帮助读者理解其实现原理。
ZooKeeper 部署
北_鱼的博客
07-20 550
记录 ZooKeeper 环境部署步骤。
解决ElasticJob项目重启ZooKeeper注册冲突以及zkCli删除目录
heyongjin22的博客
07-18 791
问题原因定时任务使用了代理，默认情况下会读取代理类名称，而不是原始类名称，导致任务名冲突。解决思路自定义一个，在项目重启时，确保读取到的是原始类名称，而不是代理类名称。实现自定义@Override在这里，我们使用方法获取原始类名，这样就避免了代理类引起的冲突问题。
磁力链磁力链磁力链.txt
最新发布
07-22
磁力链
“人力资源+大数据+薪酬报告+涨薪调薪”
07-22
人力资源+大数据+薪酬报告+涨薪调薪，在学习、工作生活中，越来越多的事务都会使用到报告，通常情况下，报告的内容含量大、篇幅较长。那么什么样的薪酬报告才是有效的呢？以下是小编精心整理的调薪申请报告，欢迎大家分享。相信老板看到这样的报告，一定会考虑涨薪的哦。
安装graphviz和pygraphviz
07-22
pygraphviz 是一个Python库，它是Graphviz图形可视化软件的Python接口。Graphviz是一个开源的图形可视化软件，广泛用于创建和编辑有向图和无向图。pygraphviz使得Python开发者能够轻松地创建和操作图形，以及执行图形的布局和可视化。 一、pygraphviz的主要功能 创建和编辑图形：pygraphviz允许开发者通过Python代码来创建图形，包括添加节点、边等元素，并且可以编辑这些元素的属性，如颜色、形状、标签等。 图形布局：pygraphviz支持多种图形布局算法，如dot、neato、circo等，开发者可以根据需要选择合适的算法来优化图形的布局。 图形可视化：pygraphviz可以将创建和编辑好的图形保存为图片文件，支持多种图片格式，如PNG、JPEG等，方便开发者进行展示和分享。
BrainF**k Devlopment Toolkit
07-22
BrainF**k Devlopment Toolkit(BFDTK)，可用于开发BrainF**k程序。
基于UC3875控制的大功率全桥开关电源设计（提供原理图、PCB图）
07-22
基于UC3875控制的大功率全桥开关电源设计（提供原理图、PCB图） 1、使用UC3875为控制芯片； 2、NCP1253为辅助电源设计，输出12V，给控制芯片供电； 3、UC3845做BOOST升压控制，实现市电整流升压到400V； 4、全桥拓扑设计结构； 5、后级输出同步整流设计； 6、过压硬件保护电路； 7、过流硬件保护电路； 8、提供原理图、PCB图；
毕业设计javajsp大学兼职信息网sqlserver-qp源码含文档工具包
07-22
毕业设计javajsp大学兼职信息网sqlserver-qp源码含文档工具包 页面是jsp，数据库sqlserver，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 （1）网站前台功能： A、信息搜索功能（分类检索） B、用户登录、注册 C、查看发布兼职信息 D、预定兼职 E、个人简历的编辑（也可以上传自己制作的简历） F、用户投诉 G、留言版 H、新闻公告（职场资讯） I、职场攻略（包含面试技巧以及简历指导） （2）管理员后台功能： A、用户信息管理
磁力链,Magnet2Torrent - 磁力链转种子利器
07-22
磁力链,Magnet2Torrent —— 磁力链转种子利器
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值