zk---分布式锁

Posted 大忽悠爱忽悠

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了zk---分布式锁相关的知识,希望对你有一定的参考价值。


什么是分布式锁

比如说"进程 1"在使用该资源的时候,会先去获得锁,"进程 1"获得锁以后会对该资源保持独占,这样其他进程就无法访问该资源,"进程 1"用完该资源以后就将锁释放掉,让其他进程来获得锁,那么通过这个锁机制,我们就能保证了分布式系统中多个进程能够有序的访问该临界资源。那么我们把这个分布式环境下的这个锁叫作分布式锁。

ZK实现分布式锁具体实现流程可以参考这篇文章


原生 Zookeeper 实现分布式锁案例

1)分布式锁实现

//通过CountDownLatch的计数器机制实现分布式锁
public class DistributedLock {
    // zookeeper server 列表
    private String connectString =
            "hadoop102:2181,hadoop103:2181,hadoop104:2181";
    // 超时时间
    private int sessionTimeout = 2000;
    private ZooKeeper zk;
    //根节点
    private String rootNode = "locks";
    //根节点下面子节点
    private String subNode = "seq-";
    // 当前 client 等待的子节点的有序序号
    private String waitPath;
    //ZooKeeper 连接
    private CountDownLatch connectLatch = new CountDownLatch(1);
    //ZooKeeper 节点等待
    private CountDownLatch waitLatch = new CountDownLatch(1);
    // 当前 client 创建的子节点
    private String currentNode;

    // 和 zk 服务建立连接,并创建根节点
    public DistributedLock() throws IOException,
            InterruptedException, KeeperException {
        zk = new ZooKeeper(connectString, sessionTimeout, new
                Watcher() {
                    @Override
                    public void process(WatchedEvent event) {
                        // 连接建立时, 打开 latch, 唤醒 wait 在该 latch 上的线程
                        if (event.getState() ==
                                Event.KeeperState.SyncConnected) {
                            connectLatch.countDown();
                        }
                        // 发生了 waitPath 的删除事件
                        if (event.getType() ==
                                Event.EventType.NodeDeleted && event.getPath().equals(waitPath)) {
                            waitLatch.countDown();
                        }
                    }
                });
        // 等待连接建立
        connectLatch.await();
        //获取根节点状态
        Stat stat = zk.exists("/" + rootNode, false);
        //如果根节点不存在,则创建根节点,根节点类型为永久节点
        if (stat == null) {
            System.out.println("根节点不存在");
            zk.create("/" + rootNode, new byte[0],
                    ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }

    // 加锁方法
    public void zkLock() {
        try {
            //在根节点下创建临时顺序节点,返回值为创建的节点路径
            currentNode = zk.create("/" + rootNode + "/" + subNode,
                    null, ZooDefs.Ids.OPEN_ACL_UNSAFE,
                    CreateMode.EPHEMERAL_SEQUENTIAL);
            // wait 一小会, 让结果更清晰一些
            Thread.sleep(10);
            // 注意, 没有必要监听"/locks"的子节点的变化情况
            List<String> childrenNodes = zk.getChildren("/" +
                    rootNode, false);
            // 列表中只有一个子节点, 那肯定就是 currentNode , 说明client 获得锁
            if (childrenNodes.size() == 1) {
                return;
            } else {
                //对根节点下的所有临时顺序节点进行从小到大排序
                Collections.sort(childrenNodes);
                //当前节点名称
                String thisNode = currentNode.substring(("/" +
                        rootNode + "/").length());
                //获取当前节点的位置
                int index = childrenNodes.indexOf(thisNode);
                if (index == -1) {
                    System.out.println("数据异常");
                } else if (index == 0) {
                    // index == 0, 说明 thisNode 在列表中最小, 当前client 获得锁
                    return;
                } else {
                    // 获得排名比 currentNode 前 1 位的节点
                    this.waitPath = "/" + rootNode + "/" +
                            childrenNodes.get(index - 1);
                    // 在 waitPath 上注册监听器, 当 waitPath 被删除时,zookeeper 会回调监听器的 process 方法
                    zk.getData(waitPath, true, new Stat());
                    //进入等待锁状态
                    waitLatch.await();
                    return;
                }
            }
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 解锁方法
    public void zkUnlock() {
        try {
            zk.delete(this.currentNode, -1);
        } catch (InterruptedException | KeeperException e) {
            e.printStackTrace();
        }
    }
}

2)分布式锁测试

(1)创建两个线程

public class DistributedLockTest {
 public static void main(String[] args) throws 
InterruptedException, IOException, KeeperException {
 // 创建分布式锁 1
 final DistributedLock lock1 = new DistributedLock();
 // 创建分布式锁 2
 final DistributedLock lock2 = new DistributedLock();
 new Thread(new Runnable() {
 @Override
 public void run() {
 // 获取锁对象
 try {
 lock1.zkLock();
 System.out.println("线程 1 获取锁");
 Thread.sleep(5 * 1000);
 lock1.zkUnlock();
 System.out.println("线程 1 释放锁");
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 }).start();
 new Thread(new Runnable() {
 @Override
 public void run() {
 // 获取锁对象
 try {
 lock2.zkLock();
 System.out.println("线程 2 获取锁");
 Thread.sleep(5 * 1000);
 lock2.zkUnlock();
 System.out.println("线程 2 释放锁");
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 }).start();
 } }

(2)观察控制台变化:

线程 1 获取锁
线程 1 释放锁
线程 2 获取锁
线程 2 释放锁

Curator 框架实现分布式锁案例

1)原生的 Java API 开发存在的问题

(1)会话连接是异步的,需要自己去处理。比如使用 CountDownLatch

(2)Watch 需要重复注册,不然就不能生效

(3)开发的复杂性还是比较高的

(4)不支持多节点删除和创建。需要自己去递归

2)Curator 是一个专门解决分布式锁的框架,解决了原生 JavaAPI 开发分布式遇到的问题。

详情请查看官方文档:https://curator.apache.org/index.html

3)Curator 案例实操

(1)添加依赖

<dependency>
 <groupId>org.apache.curator</groupId>
 <artifactId>curator-framework</artifactId>
 <version>4.3.0</version>
</dependency>
<dependency>
 <groupId>org.apache.curator</groupId>
 <artifactId>curator-recipes</artifactId>
 <version>4.3.0</version>
</dependency>
<dependency>
 <groupId>org.apache.curator</groupId>
 <artifactId>curator-client</artifactId>
 <version>4.3.0</version>
</dependency>

(2)代码实现

public class CuratorLockTest {
 private String rootNode = "/locks";
 // zookeeper server 列表
 private String connectString = 
"hadoop102:2181,hadoop103:2181,hadoop104:2181";
 // connection 超时时间
 private int connectionTimeout = 2000;
 // session 超时时间
 private int sessionTimeout = 2000;
 public static void main(String[] args) {
 new CuratorLockTest().test();
 }
 // 测试
 private void test() {
 // 创建分布式锁 1
 final InterProcessLock lock1 = new 
InterProcessMutex(getCuratorFramework(), rootNode);
 // 创建分布式锁 2
 final InterProcessLock lock2 = new 
InterProcessMutex(getCuratorFramework(), rootNode);
 new Thread(new Runnable() {
 @Override
 public void run() {
 // 获取锁对象
 try {
 lock1.acquire();
 System.out.println("线程 1 获取锁");
 // 测试锁重入
 lock1.acquire();
 System.out.println("线程 1 再次获取锁");
 Thread.sleep(5 * 1000);
 lock1.release();
 System.out.println("线程 1 释放锁");
 lock1.release();
 System.out.println("线程 1 再次释放锁");
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 }).start();
 new Thread(new Runnable() {
 @Override
 public void run() {
 // 获取锁对象
 try {
 lock2.acquire();
 System.out.println("线程 2 获取锁");
 // 测试锁重入
 lock2.acquire();
  System.out.println("线程 2 再次获取锁");
 Thread.sleep(5 * 1000);
 lock2.release();
 System.out.println("线程 2 释放锁");
 lock2.release();
 System.out.println("线程 2 再次释放锁");
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 }).start();
 }
 // 分布式锁初始化
 public CuratorFramework getCuratorFramework (){
 //重试策略,初试时间 3 秒,重试 3 次
 RetryPolicy policy = new ExponentialBackoffRetry(3000, 3);
 //通过工厂创建 Curator
 CuratorFramework client = 
CuratorFrameworkFactory.builder()
 .connectString(connectString)
 .connectionTimeoutMs(connectionTimeout)
 .sessionTimeoutMs(sessionTimeout)
 .retryPolicy(policy).build();
 //开启连接
 client.start();
 System.out.println("zookeeper 初始化完成...");
 return client;
 } }

(3)观察控制台变化:

线程 1 获取锁
线程 1 再次获取锁
线程 1 释放锁
线程 1 再次释放锁
线程 2 获取锁
线程 2 再次获取锁
线程 2 释放锁
线程 2 再次释放锁


zk知识重点总结

1.选举机制

半数机制,超过半数的投票通过,即通过。

(1)第一次启动选举规则:

投票过半数时,服务器 id 大的胜出

(2)第二次启动选举规则:

①EPOCH 大的直接胜出

②EPOCH 相同,事务 id 大的胜出

③事务 id 相同,服务器 id 大的胜出

2.生产集群安装多少 zk 合适?

安装奇数台。

生产经验:

⚫ 10 台服务器:3 台 zk;
⚫ 20 台服务器:5 台 zk;
⚫ 100 台服务器:11 台 zk;
⚫ 200 台服务器:11 台 zk

服务器台数多:好处,提高可靠性;坏处:提高通信延时

3.常用命令

ls、get、create、delete

以上是关于zk---分布式锁的主要内容,如果未能解决你的问题,请参考以下文章

ZK实现分布式锁

基于zookeeper的分布式锁实现

zk---分布式锁

Zookeeper--08---zk实现分布式锁案例

Zk实现分布式锁

zookeeper实现分布式锁