zk---分布式锁

转x33g5p2x  于2021-10-14 转载在 其他  
字(6.2k)|赞(0)|评价(0)|浏览(379)

什么是分布式锁

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

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

原生 Zookeeper 实现分布式锁案例

1）分布式锁实现

  1. //通过CountDownLatch的计数器机制实现分布式锁
  2. public class DistributedLock {
  3.     // zookeeper server 列表
  4.     private String connectString =
  5.             "hadoop102:2181,hadoop103:2181,hadoop104:2181";
  6.     // 超时时间
  7.     private int sessionTimeout = 2000;
  8.     private ZooKeeper zk;
  9.     //根节点
  10.     private String rootNode = "locks";
  11.     //根节点下面子节点
  12.     private String subNode = "seq-";
  13.     // 当前 client 等待的子节点的有序序号
  14.     private String waitPath;
  15.     //ZooKeeper 连接
  16.     private CountDownLatch connectLatch = new CountDownLatch(1);
  17.     //ZooKeeper 节点等待
  18.     private CountDownLatch waitLatch = new CountDownLatch(1);
  19.     // 当前 client 创建的子节点
  20.     private String currentNode;
  22.     // 和 zk 服务建立连接，并创建根节点
  23.     public DistributedLock() throws IOException,
  24.             InterruptedException, KeeperException {
  25.         zk = new ZooKeeper(connectString, sessionTimeout, new
  26.                 Watcher() {
  27.                     @Override
  28.                     public void process(WatchedEvent event) {
  29.                         // 连接建立时, 打开 latch, 唤醒 wait 在该 latch 上的线程
  30.                         if (event.getState() ==
  31.                                 Event.KeeperState.SyncConnected) {
  32.                             connectLatch.countDown();
  33.                         }
  34.                         // 发生了 waitPath 的删除事件
  35.                         if (event.getType() ==
  36.                                 Event.EventType.NodeDeleted && event.getPath().equals(waitPath)) {
  37.                             waitLatch.countDown();
  38.                         }
  39.                     }
  40.                 });
  41.         // 等待连接建立
  42.         connectLatch.await();
  43.         //获取根节点状态
  44.         Stat stat = zk.exists("/" + rootNode, false);
  45.         //如果根节点不存在，则创建根节点，根节点类型为永久节点
  46.         if (stat == null) {
  47.             System.out.println("根节点不存在");
  48.             zk.create("/" + rootNode, new byte[0],
  49.                     ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  50.         }
  51.     }
  53.     // 加锁方法
  54.     public void zkLock() {
  55.         try {
  56.             //在根节点下创建临时顺序节点，返回值为创建的节点路径
  57.             currentNode = zk.create("/" + rootNode + "/" + subNode,
  58.                     null, ZooDefs.Ids.OPEN_ACL_UNSAFE,
  59.                     CreateMode.EPHEMERAL_SEQUENTIAL);
  60.             // wait 一小会, 让结果更清晰一些
  61.             Thread.sleep(10);
  62.             // 注意, 没有必要监听"/locks"的子节点的变化情况
  63.             List<String> childrenNodes = zk.getChildren("/" +
  64.                     rootNode, false);
  65.             // 列表中只有一个子节点, 那肯定就是 currentNode , 说明client 获得锁
  66.             if (childrenNodes.size() == 1) {
  67.                 return;
  68.             } else {
  69.                 //对根节点下的所有临时顺序节点进行从小到大排序
  70.                 Collections.sort(childrenNodes);
  71.                 //当前节点名称
  72.                 String thisNode = currentNode.substring(("/" +
  73.                         rootNode + "/").length());
  74.                 //获取当前节点的位置
  75.                 int index = childrenNodes.indexOf(thisNode);
  76.                 if (index == -1) {
  77.                     System.out.println("数据异常");
  78.                 } else if (index == 0) {
  79.                     // index == 0, 说明 thisNode 在列表中最小, 当前client 获得锁
  80.                     return;
  81.                 } else {
  82.                     // 获得排名比 currentNode 前 1 位的节点
  83.                     this.waitPath = "/" + rootNode + "/" +
  84.                             childrenNodes.get(index - 1);
  85.                     // 在 waitPath 上注册监听器, 当 waitPath 被删除时,zookeeper 会回调监听器的 process 方法
  86.                     zk.getData(waitPath, true, new Stat());
  87.                     //进入等待锁状态
  88.                     waitLatch.await();
  89.                     return;
  90.                 }
  91.             }
  92.         } catch (KeeperException e) {
  93.             e.printStackTrace();
  94.         } catch (InterruptedException e) {
  95.             e.printStackTrace();
  96.         }
  97.     }
  99.     // 解锁方法
  100.     public void zkUnlock() {
  101.         try {
  102.             zk.delete(this.currentNode, -1);
  103.         } catch (InterruptedException | KeeperException e) {
  104.             e.printStackTrace();
  105.         }
  106.     }
  107. }

2）分布式锁测试

（1）创建两个线程

  1. public class DistributedLockTest {
  2.  public static void main(String[] args) throws 
  3. InterruptedException, IOException, KeeperException {
  4.  // 创建分布式锁 1
  5.  final DistributedLock lock1 = new DistributedLock();
  6.  // 创建分布式锁 2
  7.  final DistributedLock lock2 = new DistributedLock();
  8.  new Thread(new Runnable() {
  9.  @Override
  10.  public void run() {
  11.  // 获取锁对象
  12.  try {
  13.  lock1.zkLock();
  14.  System.out.println("线程 1 获取锁");
  15.  Thread.sleep(5 * 1000);
  16.  lock1.zkUnlock();
  17.  System.out.println("线程 1 释放锁");
  18.  } catch (Exception e) {
  19.  e.printStackTrace();
  20.  }
  21.  }
  22.  }).start();
  23.  new Thread(new Runnable() {
  24.  @Override
  25.  public void run() {
  26.  // 获取锁对象
  27.  try {
  28.  lock2.zkLock();
  29.  System.out.println("线程 2 获取锁");
  30.  Thread.sleep(5 * 1000);
  31.  lock2.zkUnlock();
  32.  System.out.println("线程 2 释放锁");
  33.  } catch (Exception e) {
  34.  e.printStackTrace();
  35.  }
  36.  }
  37.  }).start();
  38.  } }

（2）观察控制台变化：

  1. 线程 1 获取锁
  2. 线程 1 释放锁
  3. 线程 2 获取锁
  4. 线程 2 释放锁

Curator 框架实现分布式锁案例

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

（1）会话连接是异步的，需要自己去处理。比如使用 CountDownLatch

（2）Watch 需要重复注册，不然就不能生效

（3）开发的复杂性还是比较高的

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

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

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

3）Curator 案例实操

（1）添加依赖

  1. <dependency>
  2.  <groupId>org.apache.curator</groupId>
  3.  <artifactId>curator-framework</artifactId>
  4.  <version>4.3.0</version>
  5. </dependency>
  6. <dependency>
  7.  <groupId>org.apache.curator</groupId>
  8.  <artifactId>curator-recipes</artifactId>
  9.  <version>4.3.0</version>
  10. </dependency>
  11. <dependency>
  12.  <groupId>org.apache.curator</groupId>
  13.  <artifactId>curator-client</artifactId>
  14.  <version>4.3.0</version>
  15. </dependency>

（2）代码实现

  1. public class CuratorLockTest {
  2.  private String rootNode = "/locks";
  3.  // zookeeper server 列表
  4.  private String connectString = 
  5. "hadoop102:2181,hadoop103:2181,hadoop104:2181";
  6.  // connection 超时时间
  7.  private int connectionTimeout = 2000;
  8.  // session 超时时间
  9.  private int sessionTimeout = 2000;
  10.  public static void main(String[] args) {
  11.  new CuratorLockTest().test();
  12.  }
  13.  // 测试
  14.  private void test() {
  15.  // 创建分布式锁 1
  16.  final InterProcessLock lock1 = new 
  17. InterProcessMutex(getCuratorFramework(), rootNode);
  18.  // 创建分布式锁 2
  19.  final InterProcessLock lock2 = new 
  20. InterProcessMutex(getCuratorFramework(), rootNode);
  21.  new Thread(new Runnable() {
  22.  @Override
  23.  public void run() {
  24.  // 获取锁对象
  25.  try {
  26.  lock1.acquire();
  27.  System.out.println("线程 1 获取锁");
  28.  // 测试锁重入
  29.  lock1.acquire();
  30.  System.out.println("线程 1 再次获取锁");
  31.  Thread.sleep(5 * 1000);
  32.  lock1.release();
  33.  System.out.println("线程 1 释放锁");
  34.  lock1.release();
  35.  System.out.println("线程 1 再次释放锁");
  36.  } catch (Exception e) {
  37.  e.printStackTrace();
  38.  }
  39.  }
  40.  }).start();
  41.  new Thread(new Runnable() {
  42.  @Override
  43.  public void run() {
  44.  // 获取锁对象
  45.  try {
  46.  lock2.acquire();
  47.  System.out.println("线程 2 获取锁");
  48.  // 测试锁重入
  49.  lock2.acquire();
  50.   System.out.println("线程 2 再次获取锁");
  51.  Thread.sleep(5 * 1000);
  52.  lock2.release();
  53.  System.out.println("线程 2 释放锁");
  54.  lock2.release();
  55.  System.out.println("线程 2 再次释放锁");
  56.  } catch (Exception e) {
  57.  e.printStackTrace();
  58.  }
  59.  }
  60.  }).start();
  61.  }
  62.  // 分布式锁初始化
  63.  public CuratorFramework getCuratorFramework (){
  64.  //重试策略，初试时间 3 秒，重试 3 次
  65.  RetryPolicy policy = new ExponentialBackoffRetry(3000, 3);
  66.  //通过工厂创建 Curator
  67.  CuratorFramework client = 
  68. CuratorFrameworkFactory.builder()
  69.  .connectString(connectString)
  70.  .connectionTimeoutMs(connectionTimeout)
  71.  .sessionTimeoutMs(sessionTimeout)
  72.  .retryPolicy(policy).build();
  73.  //开启连接
  74.  client.start();
  75.  System.out.println("zookeeper 初始化完成...");
  76.  return client;
  77.  } }

（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

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/m0_53157173/article/details/120766378

内容来源于网络，如有侵权，请联系作者删除！

Javazookeeperspringcloud

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com