devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Apache Curator 分布式锁的介绍，以及案例

作者：繁依Fanyi0 | 2024-08-11 19:23:42

赞

踩

Apache Curator 分布式锁的介绍，以及案例

可重入锁（InterProcessMutex）：这种锁允许同一个客户端多次获取同一把锁而不会被阻塞，类似于Java中的ReentrantLock。它通过在Zookeeper的指定路径下创建临时序列节点来实现锁的功能。如果获取锁失败，当前线程会监听前一个节点的变动情况并等待，直到被唤醒或超时

  1. package com.zz.lock;
  2.  
  3. import org.apache.curator.framework.CuratorFramework;
  4. import org.apache.curator.framework.CuratorFrameworkFactory;
  5. import org.apache.curator.retry.ExponentialBackoffRetry;
  6. import org.apache.curator.framework.recipes.locks.InterProcessMutex;
  7.  
  8. public class CuratorReentrantLockExample {
  9.     private final String lockPath = "/curator/lock"; // 锁的Zookeeper路径
  10.     private CuratorFramework client; // Curator客户端
  11.     private InterProcessMutex mutex; // 可重入锁
  12.  
  13.     // 初始化Curator客户端和可重入锁
  14.     public void init() {
  15.         // 设置Zookeeper服务地址
  16.         String connectString = "192.168.200.130:2181";
  17.         // 设置重试策略
  18.         ExponentialBackoffRetry retryPolicy = new ExponentialBackoffRetry(3000, 3);
  19.         // 创建Curator客户端
  20.         client = CuratorFrameworkFactory.newClient(connectString, retryPolicy);
  21.         client.start();
  22.         // 创建可重入锁
  23.         mutex = new InterProcessMutex(client, lockPath);
  24.     }
  25.  
  26.     // 执行业务逻辑，使用可重入锁
  27.     public void executeBusinessLogic() {
  28.         try {
  29.             // 获取锁
  30.             mutex.acquire();
  31.             // 模拟业务逻辑
  32.             System.out.println("当前线程获得锁，开始执行业务逻辑。");
  33.  
  34.             // 模拟重入逻辑
  35.             reentrantLock();
  36.  
  37.             // 模拟业务逻辑
  38.             System.out.println("当前线程完成业务逻辑执行。");
  39.         } catch (Exception e) {
  40.             e.printStackTrace();
  41.         } finally {
  42.             // 确保释放锁
  43.             if (mutex.isAcquiredInThisProcess()) {
  44.                 try {
  45.                     mutex.release();
  46.                 } catch (Exception e) {
  47.                     e.printStackTrace();
  48.                 }
  49.             }
  50.         }
  51.     }
  52.  
  53.     // 模拟可重入逻辑
  54.     public void reentrantLock() {
  55.         try {
  56.             // 再次获取同一把锁
  57.             mutex.acquire();
  58.             System.out.println("当前线程重入成功，再次获得同一把锁。");
  59.             // 模拟一些操作...
  60.         } catch (Exception e) {
  61.             e.printStackTrace();
  62.         } finally {
  63.             // 释放锁
  64.             if (mutex.isAcquiredInThisProcess()) {
  65.                 try {
  66.                     mutex.release();
  67.                 } catch (Exception e) {
  68.                     e.printStackTrace();
  69.                 }
  70.             }
  71.         }
  72.     }
  73.  
  74.     // 程序入口
  75.     public static void main(String[] args) {
  76.         CuratorReentrantLockExample example = new CuratorReentrantLockExample();
  77.         example.init();
  78.         // 执行业务逻辑
  79.         example.executeBusinessLogic();
  80.     }
  81. }

不可重入锁（InterProcessSemaphoreMutex）：与可重入锁类似，但不允许同一个线程在持有锁的情况下再次获取该锁。这种锁很容易导致死锁，使用时需要特别注意

  1. import org.apache.curator.framework.CuratorFramework;
  2. import org.apache.curator.framework.CuratorFrameworkFactory;
  3. import org.apache.curator.retry.ExponentialBackoffRetry;
  4. import org.apache.curator.framework.recipes.locks.InterProcessMutex;
  5.  
  6. public class CuratorReentrantLockExample {
  7.     private final String lockPath = "/curator/lock"; // 锁的Zookeeper路径
  8.     private CuratorFramework client; // Curator客户端
  9.     private InterProcessMutex mutex; // 可重入锁
  10.  
  11.     // 初始化Curator客户端和可重入锁
  12.     public void init() {
  13.         // 设置Zookeeper服务地址
  14.         String connectString = "127.0.0.1:2181";
  15.         // 设置重试策略
  16.         ExponentialBackoffRetry retryPolicy = new ExponentialBackoffRetry(3000, 3);
  17.         // 创建Curator客户端
  18.         client = CuratorFrameworkFactory.newClient(connectString, retryPolicy);
  19.         client.start();
  20.         // 创建可重入锁
  21.         mutex = new InterProcessMutex(client, lockPath);
  22.     }
  23.  
  24.     // 执行业务逻辑，使用可重入锁
  25.     public void executeBusinessLogic() {
  26.         try {
  27.             // 获取锁
  28.             mutex.acquire();
  29.             // 模拟业务逻辑
  30.             System.out.println("当前线程获得锁，开始执行业务逻辑。");
  31.  
  32.             // 模拟重入逻辑
  33.             reentrantLock();
  34.  
  35.             // 模拟业务逻辑
  36.             System.out.println("当前线程完成业务逻辑执行。");
  37.         } catch (Exception e) {
  38.             e.printStackTrace();
  39.         } finally {
  40.             // 确保释放锁
  41.             if (mutex.isAcquiredInThisProcess()) {
  42.                 try {
  43.                     mutex.release();
  44.                 } catch (Exception e) {
  45.                     e.printStackTrace();
  46.                 }
  47.             }
  48.         }
  49.     }
  50.  
  51.     // 模拟可重入逻辑
  52.     public void reentrantLock() {
  53.         try {
  54.             // 再次获取同一把锁
  55.             mutex.acquire();
  56.             System.out.println("当前线程重入成功，再次获得同一把锁。");
  57.             // 模拟一些操作...
  58.         } catch (Exception e) {
  59.             e.printStackTrace();
  60.         } finally {
  61.             // 释放锁
  62.             if (mutex.isAcquiredInThisProcess()) {
  63.                 try {
  64.                     mutex.release();
  65.                 } catch (Exception e) {
  66.                     e.printStackTrace();
  67.                 }
  68.             }
  69.         }
  70.     }
  71.  
  72.     // 程序入口
  73.     public static void main(String[] args) {
  74.         CuratorReentrantLockExample example = new CuratorReentrantLockExample();
  75.         example.init();
  76.         // 执行业务逻辑
  77.         example.executeBusinessLogic();
  78.     }
  79. }

读写锁（InterProcessReadWriteLock）：提供一对相关的锁，读锁可以被多个读操作共享，而写锁则独占。一个拥有写锁的线程可以获取读锁，但读锁不能升级为写锁。这种锁是公平的，保证用户按请求顺序获取锁。（读写锁在逻辑上有点像数据库的事务）

  1. package com.zz.lock;
  2.  
  3. import org.apache.curator.framework.CuratorFramework;
  4. import org.apache.curator.framework.CuratorFrameworkFactory;
  5. import org.apache.curator.retry.ExponentialBackoffRetry;
  6. import org.apache.curator.framework.recipes.locks.InterProcessReadWriteLock;
  7.  
  8. public class CuratorReadWriteLockExample {
  9.     private final String lockPath = "/curator/read-write-lock"; // 锁的Zookeeper路径
  10.     private CuratorFramework client; // Curator客户端
  11.     private InterProcessReadWriteLock lock; // 读写锁
  12.  
  13.     // 初始化Curator客户端和读写锁
  14.     public void init() {
  15.         // 设置Zookeeper服务地址
  16.         String connectString = "192.168.200.130:2181";
  17.         // 设置重试策略
  18.         ExponentialBackoffRetry retryPolicy = new ExponentialBackoffRetry(3000, 3);
  19.         // 创建Curator客户端
  20.         client = CuratorFrameworkFactory.newClient(connectString, retryPolicy);
  21.         client.start();
  22.         // 创建读写锁
  23.         lock = new InterProcessReadWriteLock(client, lockPath);
  24.     }
  25.  
  26.     // 执行读操作
  27.     public void executeReadOperation() throws Exception {
  28.         try {
  29.             // 获取读锁
  30.             lock.readLock().acquire();
  31.             // 模拟读操作
  32.             System.out.println("读操作开始，线程安全地读取数据。");
  33.             // 模拟读操作延迟
  34.             Thread.sleep(3000);
  35.             System.out.println("读操作结束。");
  36.         } catch (Exception e) {
  37.             e.printStackTrace();
  38.         } finally {
  39.             // 释放读锁
  40.             if (lock.readLock().isAcquiredInThisProcess()) {
  41.                 lock.readLock().release();
  42.             }
  43.         }
  44.     }
  45.  
  46.     // 执行写操作
  47.     public void executeWriteOperation() throws Exception {
  48.         try {
  49.             // 获取写锁
  50.             lock.writeLock().acquire();
  51.             // 模拟写操作
  52.             System.out.println("写操作开始，线程独占资源进行写入。");
  53.             // 模拟写操作延迟
  54.             Thread.sleep(3000);
  55.             System.out.println("写操作结束，更新了数据。");
  56.         } catch (Exception e) {
  57.             e.printStackTrace();
  58.         } finally {
  59.             // 释放写锁
  60.             if (lock.writeLock().isAcquiredInThisProcess()) {
  61.                 lock.writeLock().release();
  62.             }
  63.         }
  64.     }
  65.  
  66.     // 程序入口
  67.     public static void main(String[] args) {
  68.         CuratorReadWriteLockExample example = new CuratorReadWriteLockExample();
  69.         example.init();
  70.  
  71.         // 启动多个读操作线程
  72.         for (int i = 0; i < 5; i++) {
  73.             new Thread(() -> {
  74.                 try {
  75.                     example.executeReadOperation();
  76.                 } catch (Exception e) {
  77.                     e.printStackTrace();
  78.                 }
  79.             }).start();
  80.         }
  81.  
  82.         // 启动写操作线程
  83.         new Thread(() -> {
  84.             try {
  85.                 example.executeWriteOperation();
  86.             } catch (Exception e) {
  87.                 e.printStackTrace();
  88.             }
  89.         }).start();
  90.     }
  91. }

联锁（InterProcessMultiLock）：这是一个锁的容器，可以同时获取多个锁。如果获取过程中任何一个锁请求失败，已获取的所有锁都会被释放。这在需要同时持有多个锁执行操作的场景中非常有用

  1. import org.apache.curator.framework.CuratorFramework;
  2. import org.apache.curator.framework.CuratorFrameworkFactory;
  3. import org.apache.curator.retry.ExponentialBackoffRetry;
  4. import org.apache.curator.framework.recipes.locks.InterProcessLock;
  5. import org.apache.curator.framework.recipes.locks.InterProcessMultiLock;
  6. import java.util.Arrays;
  7. import java.util.List;
  8.  
  9. public class InterProcessMultiLockExample {
  10.     private CuratorFramework client;
  11.     private List<String> lockPaths = Arrays.asList("/lock1", "/lock2", "/lock3");
  12.     private List<InterProcessLock> locks = lockPaths.stream()
  13.             .map(path -> new InterProcessMutex(client, path))
  14.             .collect(Collectors.toList());
  15.     private InterProcessMultiLock multiLock;
  16.  
  17.     public void init() {
  18.         String connectString = "127.0.0.1:2181";
  19.         RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 3);
  20.         client = CuratorFrameworkFactory.newClient(connectString, retryPolicy);
  21.         client.start();
  22.         multiLock = new InterProcessMultiLock(locks);
  23.     }
  24.  
  25.     public void executeProtectedOperation() {
  26.         try {
  27.             multiLock.acquire();
  28.             // 所有锁都已获取，执行你的业务逻辑
  29.             System.out.println("All locks acquired, performing business logic.");
  30.             // 业务逻辑...
  31.         } catch (Exception e) {
  32.             e.printStackTrace();
  33.         } finally {
  34.             // 确保释放所有锁
  35.             multiLock.release();
  36.         }
  37.     }
  38.  
  39.     public static void main(String[] args) {
  40.         InterProcessMultiLockExample example = new InterProcessMultiLockExample();
  41.         example.init();
  42.         example.executeProtectedOperation();
  43.     }
  44. }

信号量（InterProcessSemaphoreV2）：Curator提供了一种信号量实现，可以控制同时访问某个资源的线程数量。通过acquire方法请求获取信号量，使用完成后通过returnAll方法释放

  1. 信号量（Semaphore）确实可以起到限流的作用。在分布式系统中，信号量是一种常用的限流工具，它通过控制同时访问某个资源或执行某个操作的线程数量来实现限流。以下是信号量实现限流的几个关键点：
  2.  
  3. 1. **资源限制**：信号量通过一个计数器来限制可用资源的数量。例如，如果你有10个停车位，你可以设置信号量的初始值为10。
  4.  
  5. 2. **请求处理**：当一个线程需要访问资源时，它首先尝试从信号量中获取一个“许可”（lease）。如果信号量的计数器大于0，该线程成功获取一个许可，然后继续执行。否则，线程将被阻塞，直到其他线程释放资源。
  6.  
  7. 3. **释放资源**：线程完成资源访问后，必须释放它获取的许可，通过将许可返还给信号量来实现。这会将信号量的计数器增加1，允许其他等待的线程获取许可。
  8.  
  9. 4. **公平性**：信号量通常是公平的，意味着线程将按照它们请求许可的顺序来获得它们。这有助于避免某些线程长时间等待访问资源。
  10.  
  11. 5. **跨JVM共享**：在分布式系统中，不同的进程可能在不同的JVM中运行。Apache Curator 提供的 `InterProcessSemaphoreV2` 允许跨JVM共享信号量状态，因此所有相关进程都能协调地访问共享资源。
  12.  
  13. 6. **自动资源回收**：如果持有信号量许可的线程或进程崩溃，Curator 会自动释放该许可，确保资源不会被永久占用，其他线程可以继续获取该资源。
  14.  
  15. 通过这种方式，信号量可以有效地控制对共享资源的并发访问，防止系统过载，从而实现限流。这在许多场景下都非常有用，比如数据库连接池、线程池、外部服务调用等。
  1. import org.apache.curator.framework.CuratorFramework;
  2. import org.apache.curator.framework.CuratorFrameworkFactory;
  3. import org.apache.curator.framework.recipes.locks.InterProcessSemaphoreV2;
  4. import org.apache.curator.framework.recipes.locks.Lease;
  5. import org.apache.curator.retry.ExponentialBackoffRetry;
  6.  
  7. public class InterProcessSemaphoreV2Demo {
  8.     private static final String PATH = "/semaphore/path";
  9.     private static CuratorFramework client;
  10.  
  11.     public static void main(String[] args) throws Exception {
  12.         // 初始化Curator客户端
  13.         client = CuratorFrameworkFactory.newClient(
  14.             "localhost:2181", 
  15.             new ExponentialBackoffRetry(3000, 2)
  16.         );
  17.         client.start();
  18.  
  19.         // 创建InterProcessSemaphoreV2实例，设置最大租约数为5
  20.         InterProcessSemaphoreV2 semaphore = new InterProcessSemaphoreV2(client, PATH, 5);
  21.  
  22.         // 线程示例，模拟同时请求信号量的多个线程
  23.         for (int i = 0; i < 10; i++) {
  24.             new Thread(new SemaphoreTask(semaphore)).start();
  25.         }
  26.  
  27.         // 等待一段时间，让线程执行
  28.         Thread.sleep(10000);
  29.  
  30.         // 关闭客户端连接
  31.         client.close();
  32.     }
  33.  
  34.     static class SemaphoreTask implements Runnable {
  35.         private final InterProcessSemaphoreV2 semaphore;
  36.  
  37.         public SemaphoreTask(InterProcessSemaphoreV2 semaphore) {
  38.             this.semaphore = semaphore;
  39.         }
  40.  
  41.         @Override
  42.         public void run() {
  43.             try {
  44.                 Lease lease = semaphore.acquire();
  45.                 System.out.println(Thread.currentThread().getName() + " acquired a lease.");
  46.                 // 模拟业务逻辑处理
  47.                 Thread.sleep(3000);
  48.                 // 释放信号量租约
  49.                 semaphore.returnLease(lease);
  50.                 System.out.println(Thread.currentThread().getName() + " returned a lease.");
  51.             } catch (Exception e) {
  52.                 e.printStackTrace();
  53.             }
  54.         }
  55.     }
  56. }

 

分布式锁的实现原理：Curator的分布式锁通常是基于Zookeeper的临时顺序节点来实现的。当多个客户端尝试获取锁时，Zookeeper会为它们创建顺序节点，并让它们按照节点的序号依次尝试获取锁。未获取到锁的客户端会监听前一个序号的节点，一旦前一个节点释放锁，监听的客户端就会尝试获取锁

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/965703
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号