Zookeeper实现分布式锁

最新推荐文章于 2024-05-09 18:35:51 发布

火星日立zy

最新推荐文章于 2024-05-09 18:35:51 发布

阅读量474

点赞数 1

分类专栏： Java 架构

本文链接：https://blog.csdn.net/u013080921/article/details/79343132

版权

Java 同时被 2 个专栏收录

14 篇文章 0 订阅

订阅专栏

架构

3 篇文章 0 订阅

订阅专栏

一.zookeeper是一款分布式协调框架，简单的说，zookeeper=文件系统+通知机制。，主要作用：1.命名服务 2.配置管理（数据发布与订阅） 3.集群管理 4.分布式锁 5.队列管理。

我最开始了解zookeeper是源于我们的RPC框架Pigeon，里面使用它作为协调管理工具，管理服务实现者和服务请求者。本机下载安装zookeeper还是挺容易的，参考http://blog.csdn.net/leiyu231/article/details/52292373。我的mac配置文件在：/usr/local/etc/zookeeper。

二.实现分布式锁常用三种方式：1）数据库实现 2）redis实现 3）zookeeper实现。

下面就来实现基于zookeeper实现的分布式锁。流程如下：

<1>所有客户端创建自己的锁节点
<2>从 Zookeeper 端获取 /share_lock 下所有的子节点
<3>判断自己创建的锁节点是否可以获取锁，如果可以，持有锁。否则对自己关心的锁节点设置 watcher
<4>持有锁的客户端删除自己的锁节点，某个客户端收到该节点被删除的通知，并获取锁

<5>重复步骤4，直至无客户端在等待获取锁了

流程图如下：

实现如下：

加锁有3个方法，类似于java.util.concurrent.locks.Lock里面的3个加锁方法。

import org.apache.commons.lang.StringUtils;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * zookeeper实现分布式锁
 * Created by zhouyu on 18/2/22.
 */
public class DistributedLock implements Watcher {

    /***
     * zookeeper默认端口2181
     * zookeeper集群地址
     */
    private final static String host = "localhost:2181";
    /**
     * ZooKeeper对象
     */
    private ZooKeeper zk;
    /***
     * 锁的对象,竞争的资源
     */
    private String lockName;
    /***
     * 基本路径,根节点
     */
    private String root = "/locks";
    /***
     * 计数器
     */
    private CountDownLatch countDownLatch;
    /**
     * 当前锁
     */
    private String CURRENT_LOCK;
    /**
     * 当前锁的前一个锁
     */
    private String WAIT_LOCK;

/**
 * 设置标志位 防止死锁发生
 * */
private  boolean flag=true;

public DistributedLock(String lockName) { this.lockName = lockName; if (StringUtils.isBlank(lockName)) { throw new IllegalArgumentException("lockName is wrong"); } try { //新建立对象根节点,并设置watcher zk = new ZooKeeper(host, 3000, this); Stat stat = zk.exists(root, false); //跟节点不存在则新建,永久节点 if (stat == null) { zk.create(root, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); } } catch (Exception e) { e.printStackTrace(); } } /** * 加锁方法阻塞模式 */ public void lock() { try { if (tryLock()) { System.out.println(Thread.currentThread().getName() + " " + lockName + "获得了锁"); } else { // 等待锁 waitForLock(WAIT_LOCK, 0,false); } } catch (Exception e) { e.printStackTrace(); } } /** * * * @param WAIT_LOCK 需要等待的上一个锁,如果他被删除,自己就能获得锁 * @param time 执行的等待时间 * @param isWaitForTime 是否根据time等待 * */ private boolean waitForLock(String WAIT_LOCK,long time,boolean isWaitForTime)throws Exception{ Stat stat = zk.exists(root + "/" + WAIT_LOCK, true); if (stat != null) { countDownLatch = new CountDownLatch(1); if(isWaitForTime){ //时间到时,如果计数为0,则返回true,否则返回false; return countDownLatch.await(time,TimeUnit.MILLISECONDS); }else { countDownLatch.await(); } countDownLatch = null; } return true; } /*** * 释放锁 * 就是将自己的临时子节点删除 */ public void unlock() { try { System.out.println("释放锁 " + CURRENT_LOCK); //-1代表不需要比较version zk.delete(CURRENT_LOCK, -1); CURRENT_LOCK = null; zk.close(); } catch (Exception e) { e.printStackTrace(); } } /*** * 尝试获取锁 * 1次判断,获取不到就返回 * 最基本的加锁方法。 * 建立临时有序子节点,并判断该节点是否为最小的子节点,是就加锁成功,否则返回 */ public boolean tryLock() throws Exception { CURRENT_LOCK = zk.create(root + "/" + lockName + "_lock_", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL); System.out.println(Thread.currentThread().getName() + " :" + CURRENT_LOCK + " 已经创建"); // 取所有子节点 List<String> subNodes = zk.getChildren(root, false); // 取出所有lockName的锁 List<String> lockObjects = new ArrayList<>(); for (String node : subNodes) { String _node = node.split("_lock_")[0]; if (_node.equals(lockName)) { lockObjects.add(node); } } //排序 Collections.sort(lockObjects); System.out.println(Thread.currentThread().getName() + " 的锁是 " + CURRENT_LOCK); // 若当前节点为最小节点，则获取锁成功 if (CURRENT_LOCK.equals(root + "/" + lockObjects.get(0))) { return true; } // 若不是最小节点，则找到自己的前一个节点 String prevNode = CURRENT_LOCK.substring(CURRENT_LOCK.lastIndexOf("/") + 1); WAIT_LOCK = lockObjects.get(Collections.binarySearch(lockObjects, prevNode) - 1); return false; } /** * 有时间限制的阻塞式取锁 * @param time 等待时间数单位:毫秒 * */ public boolean tryLock(long time)throws Exception{ try { if (tryLock()) { return true; } else { return waitForLock(WAIT_LOCK, time, true); } }catch (Exception e){ e.printStackTrace(); } return false; } /** * 节点监视器 * 监听子节点的变动, 只有是删除节点的时候,countDownLatch不会空。 * @param event 监听事件 */ public void process(WatchedEvent event) { if (this.countDownLatch != null) { this.countDownLatch.countDown(); }

      flag=false；

}}

测试代码如下：

 public static void main(String[] args){
        Runnable runnable = new Runnable() {
            public void run() {
                DistributedLock lock = null;
                try {
                    lock = new DistributedLock("hello");
                    lock.lock();//阻塞模式
                    System.out.println(Thread.currentThread().getName() + "正在运行");
                } catch (Exception e){
                    e.printStackTrace();
                }finally {
                    if (lock != null) {
                        lock.unlock();
                    }
                }
            }
        };

        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(runnable);
            t.start();
        }
    }

结果如下：可以看出是有序执行

Thread-1 :/locks/hello_lock_0000000663 已经创建
Thread-3 :/locks/hello_lock_0000000665 已经创建
Thread-5 :/locks/hello_lock_0000000664 已经创建
Thread-8 :/locks/hello_lock_0000000666 已经创建
Thread-2 :/locks/hello_lock_0000000668 已经创建
Thread-9 :/locks/hello_lock_0000000667 已经创建
Thread-7 :/locks/hello_lock_0000000669 已经创建
Thread-4 :/locks/hello_lock_0000000671 已经创建
Thread-6 :/locks/hello_lock_0000000670 已经创建
Thread-0 :/locks/hello_lock_0000000672 已经创建
Thread-3 的锁是 /locks/hello_lock_0000000665
Thread-5 的锁是 /locks/hello_lock_0000000664
Thread-6 的锁是 /locks/hello_lock_0000000670
Thread-9 的锁是 /locks/hello_lock_0000000667
Thread-7 的锁是 /locks/hello_lock_0000000669
Thread-1 的锁是 /locks/hello_lock_0000000663
Thread-1 hello获得了锁
Thread-1正在运行
释放锁 /locks/hello_lock_0000000663
Thread-8 的锁是 /locks/hello_lock_0000000666
Thread-0 的锁是 /locks/hello_lock_0000000672
Thread-2 的锁是 /locks/hello_lock_0000000668
Thread-4 的锁是 /locks/hello_lock_0000000671
Thread-5正在运行
释放锁 /locks/hello_lock_0000000664
Thread-3正在运行
释放锁 /locks/hello_lock_0000000665
Thread-8正在运行
释放锁 /locks/hello_lock_0000000666
Thread-9正在运行
释放锁 /locks/hello_lock_0000000667
Thread-2正在运行
释放锁 /locks/hello_lock_0000000668
Thread-7正在运行
释放锁 /locks/hello_lock_0000000669
Thread-6正在运行
释放锁 /locks/hello_lock_0000000670
Thread-4正在运行
释放锁 /locks/hello_lock_0000000671
Thread-0正在运行
释放锁 /locks/hello_lock_0000000672

参考：

http://blog.csdn.net/leiyu231/article/details/52292373

https://www.cnblogs.com/liuyang0/p/6800538.html

https://segmentfault.com/a/1190000010895869

火星日立zy

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
Zookeeper实现分布式锁

一.zookeeper是一款分布式协调框架，简单的说，zookeeper=文件系统+通知机制。，主要作用：1.命名服务 2.配置管理（数据发布与订阅） 3.集群管理 4.分布式锁 5.队列管理。我最开始了解zookeeper是源于我们的RPC框架Pigeon，里面使用它作为协调管理工具，管理服务实现者和服务请求者。本机下载安装zookeeper还是挺容易的，参考http://blog...
复制链接

扫一扫