十、ZooKeeper 分布式锁案例

最新推荐文章于 2024-05-13 23:02:43 发布

悬浮海

最新推荐文章于 2024-05-13 23:02:43 发布

阅读量394

点赞数

分类专栏： # zookeeper 文章标签： ZooKeeper分布式锁案例

本文链接：https://blog.csdn.net/wang_luwei/article/details/124898767

版权

zookeeper 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

本文深入探讨了使用ZooKeeper原生API和Curator框架实现分布式锁的案例。首先，详细展示了如何利用ZooKeeper创建临时有序节点来竞争锁，以及在节点删除时的监听机制。接着，分析了使用Curator框架简化分布式锁实现的优势，如自动处理会话连接、重试策略等。最后，给出了Curator实现分布式锁的代码示例，包括加锁、释放锁的过程。

摘要由CSDN通过智能技术生成

zk目录

文章目录

十、ZooKeeper 分布式锁案例

十、ZooKeeper 分布式锁案例

什么叫做分布式锁呢？

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

那么我们把这个分布式环境下的这个锁叫作分布式锁。

分布式锁案例分析：

客户端访问集群，客户端访问，常见临时的带序号的节点，序号最小的拿到资源（加锁），走业务逻辑，解锁就是删除改节点。

所以每个客户端创建的节点都会判断自己是不是序号最小的节点，如果不是就监听其前一个节点。

5-1

10.1、原生 Zookeeper 实现分布式锁案例

10.1.1、分布式锁实现

package com.wlw.case2;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;

/**
 * 分布式锁案例
 */
public class DistributedLock {

    // 注意：逗号左右不能有空格
    private String connectString = "wlw102:2181,wlw103:2181,wlw104:2181";
    private int sessionTimeout = 2000;
    private final ZooKeeper zk;

    private CountDownLatch connectLatch = new CountDownLatch(1);
    private CountDownLatch waitLatch = new CountDownLatch(1);

    // 前一个节点路径
    private String waitPath;
    // 当前客户端创建的节点
    private String currentMode;

    /**
     * 无参构造
     */
    public DistributedLock() throws IOException, InterruptedException, KeeperException {

        // 获取连接
        zk = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                // connectLatch  如果连接上zk  可以释放
                if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                    // 状态是已连接。释放
                    connectLatch.countDown();
                }

                // waitLatch  需要释放
                if (watchedEvent.getType() == Event.EventType.NodeDeleted && watchedEvent.getPath().equals(waitPath)) {
                    // 如果是节点的删除，并且路径是前一个节点路径，释放
                    waitLatch.countDown();
                }
            }
        });
        // 等待zk正常连接后，往下走程序，阻塞
        connectLatch.await();
        // 判断根节点/locks是否存在
        Stat stat = zk.exists("/locks", false);

        if (stat == null) {
            // 不存在则创建节点/locks
            zk.create("/locks", "locks".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }
    
    /**
     * 对zk加锁 (创建对应的临时带序号节点)
     */
    public void zkLock() {

        try {
            // 第一步：创建对应的临时带序号节点
            currentMode = zk.create("/locks/" + "seq-", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);

            // wait一小会, 让结果更清晰一些
            Thread.sleep(10);

            // 第二步：判断创建的节点是否是最小的序号节点，如果是获取到锁；如果不是，监听他序号前一个节点
            // 获取此路径下的所有子节点
            List<String> children = zk.getChildren("/locks", false);

            // 如果children 只有一个值，说明只有它一个客户端，那就直接获取锁； 如果有多个节点，需要判断，谁最小
            if (children.size() == 1) {
                return;
            } else {
                // 对所有子节点进行排序
                Collections.sort(children);

                // 获取当前客户端创建的节点名称， 如：seq-00000000，
                // 这里使用截取，是因为获取到的是节点的路径如：/locks/seq-0000000000
                String thisNode = currentMode.substring("/locks/".length());
                // 通过节点名（如：seq-00000000）获取该节点在children集合的位置
                int index = children.indexOf(thisNode);

                // 判断
                if (index == -1) {
                    System.out.println("数据异常");
                } else if (index == 0) {
                    // 当前客户端对应的节点是第一个节点，可以获取锁了
                    return;
                } else {
                    // 不是第一个节点，需要监听前一个节点变化
                    waitPath = "/locks/" + children.get(index - 1);
                    // 需要监听，所以第二个参数为 true
                    zk.getData(waitPath, true, new Stat());

                    // 等待监听
                    waitLatch.await();

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

    /**
     * 解锁(删除节点)
     */
    public void unZkLock() {

        // 删除当前客户端创建的节点
        try {
            zk.delete(this.currentMode, -1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }
}

10.1.2、分布式锁测试

package com.wlw.case2;

import org.apache.zookeeper.KeeperException;

import java.io.IOException;

/**
 * 分布式锁测试
 */
public class DistributedLockTest {

    public static void main(String[] args) throws InterruptedException, IOException, KeeperException {

       final  DistributedLock lock1 = new DistributedLock();
       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.unZkLock();
                   System.out.println("线程1 释放锁");
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {

                try {
                    // 加锁
                    lock2.zkLock();
                    System.out.println("线程2 启动，获取到锁");
                    Thread.sleep(5 * 1000);

                    // 解锁
                    lock2.unZkLock();
                    System.out.println("线程2 释放锁");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

观察控制台变化：

线程1 启动，获取到锁
线程1 释放锁
线程2 启动，获取到锁
线程2 释放锁

10.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）代码实现

package com.wlw.case3;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;

/**
 * Curator 框架实现分布式锁案例
 */
public class CuratorLockTest {

    public static void main(String[] args) {
        // 创建分布式锁1
        final InterProcessMutex lock1 = new InterProcessMutex(getCuratorFramework(), "/locks");

        // 创建分布式锁2
        final InterProcessMutex lock2 = new InterProcessMutex(getCuratorFramework(), "/locks");

        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();
    }

    /**
     * 启动zk
     */
    private static CuratorFramework getCuratorFramework() {
        // 重试策略
        ExponentialBackoffRetry policy = new ExponentialBackoffRetry(3000, 3);

        CuratorFramework client = CuratorFrameworkFactory.builder().connectString("wlw102:2181,wlw103:2181,wlw104:2181")
                .connectionTimeoutMs(2000)
                .sessionTimeoutMs(2000)
                .retryPolicy(policy).build();

        // 启动客户端
        client.start();

        System.out.println("zookeeper 启动成功");
        return client;
    }
}

测试，观察观察控制台变化：

线程1 获取到锁

线程1 再次获取到锁（可重入）

线程1 释放锁

线程1 再次释放锁

线程2 获取到锁

线程2 再次获取到锁（可重入）

线程2 释放锁

线程2 再次释放锁

悬浮海

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
十、ZooKeeper 分布式锁案例

zk目录文章目录十、ZooKeeper 分布式锁案例10.1、原生 Zookeeper 实现分布式锁案例10.1.1、分布式锁实现10.1.2、分布式锁测试10.2、Curator 框架实现分布式锁案例十、ZooKeeper 分布式锁案例什么叫做分布式锁呢？比如说 “进程1” 在使用该资源的时候，会先去获得锁，"进程 1"获得锁以后会对该资源保持独占，这样其他进程就无法访问该资源，"进程 1"用完该资源以后就将锁释放掉，让其他进程来获得锁，那么通过这个锁机制，我们就能保证了分布式系统中多个进程能
复制链接

扫一扫