分布式锁看了又看，优秀方案我来告诉你

分布式锁看了又看，优秀方案我来告诉你

作者：老郑 2021-04-12 08:02:12

开发

前端

分布式 对于商品秒杀的场景，我们需要防止库存超卖或者重复扣款等并发问题，我们通常需要使用分布式锁，来解决共享资源竞争导致数据不一致的问题。本篇就讲解如何用分布式锁的来解决此类问题。

成都创新互联是专业的丰满网站建设公司，丰满接单;提供网站设计、成都网站制作,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行丰满网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

[[392389]]

分布式锁的场景

秒杀场景案例

对于商品秒杀的场景，我们需要防止库存超卖或者重复扣款等并发问题，我们通常需要使用分布式锁，来解决共享资源竞争导致数据不一致的问题。

以手机秒杀的场景为例子，在抢购的过程中通常我们有三个步骤：

扣掉对应商品的库存;2. 创建商品的订单;3. 用户支付。

对于这样的场景我们就可以采用分布式锁的来解决，比如我们在用户进入秒杀 “下单“ 链接的过程中，我们可以对商品库存进行加锁，然后完成扣库存和其他操作，操作完成后。释放锁，让下一个用户继续进入保证库存的安全性;也可以减少因为秒杀失败，导致 DB 回滚的次数。整个流程如下图所示：

注：对于锁的粒度要根据具体的场景和需求来权衡。

三种分布式锁

对于 Zookeeper 的分布式锁实现，主要是利用 Zookeeper 的两个特征来实现：

  1. Zookeeper 的一个节点不能被重复创建
  2. Zookeeper 的 Watcher 监听机制

非公平锁

对于非公平锁，我们在加锁的过程如下图所示。

优点和缺点

其实上面的实现有优点也有缺点：

优点：

实现比较简单，有通知机制，能提供较快的响应，有点类似 ReentrantLock 的思想，对于节点删除失败的场景由 Session 超时保证节点能够删除掉。

缺点：

重量级，同时在大量锁的情况下会有 “惊群” 的问题。

“惊群” 就是在一个节点删除的时候，大量对这个节点的删除动作有订阅 Watcher 的线程会进行回调，这对Zk集群是十分不利的。所以需要避免这种现象的发生。

解决“惊群”：

为了解决“惊群“问题，我们需要放弃订阅一个节点的策略，那么怎么做呢?

  1. 我们将锁抽象成目录，多个线程在此目录下创建瞬时的顺序节点，因为 Zookeeper 会为我们保证节点的顺序性，所以可以利用节点的顺序进行锁的判断。
  2. 首先创建顺序节点，然后获取当前目录下最小的节点，判断最小节点是不是当前节点，如果是那么获取锁成功，如果不是那么获取锁失败。
  3. 获取锁失败的节点获取当前节点上一个顺序节点，对此节点注册监听，当节点删除的时候通知当前节点。
  4. 当unlock的时候删除节点之后会通知下一个节点。

公平锁

基于非公平锁的缺点，我们可以通过一下的方案来规避。

优点和缺点

优点： 如上借助于临时顺序节点，可以避免同时多个节点的并发竞争锁，缓解了服务端压力。

缺点： 对于读写场景来说，无法解决一致性的问题，如果读的时候也去获取锁的话，这样会导致性能下降，对于这样的问题，我们可以通过读写锁来实现如类似 jdk 中的 ReadWriteLock

读写锁实现

对于读写锁的特点：读写锁在如果多个线程都是在读的时候，是可以并发读的，就是一个无锁的状态，如果有写锁正在操作的时候，那么读锁需要等待写锁。在加写锁的时候，由于前面的读锁都是并发，所以需要监听最后一个读锁完成后执行写锁。步骤如下：

  1. read 请求， 如果前面是读锁，可以直接读取，不需要监听。如果前面是一个或者多个写锁那么只需要监听最后一个写锁。
  2. write 请求，只需要对前面的节点监听。Watcher 机制和互斥锁一样。

分布式锁实战

本文源码中使用环境：JDK 1.8 、Zookeeper 3.6.x

Curator 组件实现

POM 依赖

  
 
 
 
    
   
  
  
  
  1.  
    2. 
   
  
  
  
  2.   org.apache.curator 
    3. 
   
  
  
  
  3.   curator-framework 
    4. 
   
  
  
  
  4.   2.13.0 
    5. 
   
  
  
  
  5.  
    6. 
   
  
  
  
  6.  
    7. 
   
  
  
  
  7.   org.apache.curator 
    8. 
   
  
  
  
  8.   curator-recipes 
    9. 
   
  
  
  
  9.   2.13.0 
    10. 
   
  
  
  
  10.  
    11.

互斥锁运用

由于 Zookeeper 非公平锁的 “惊群” 效应，非公平锁在 Zookeeper 中其实并不是最好的选择。下面是一个模拟秒杀的例子来使用 Zookeeper 分布式锁。

  
 
 
 
    
   
  
  
  
  1. public class MutexTest { 
    2. 
   
  
  
  
  2.     static ExecutorService executor = Executors.newFixedThreadPool(8); 
    3. 
   
  
  
  
  3.     static AtomicInteger stock = new AtomicInteger(3); 
    4. 
   
  
  
  
  4.     public static void main(String[] args) throws InterruptedException { 
    5. 
   
  
  
  
  5.         CuratorFramework client = getZkClient(); 
    6. 
   
  
  
  
  6.         String key = "/lock/lockId_111/111"; 
    7. 
   
  
  
  
  7.         final InterProcessMutex mutex = new InterProcessMutex(client, key); 
    8. 
   
  
  
  
  8.         for (int i = 0; i < 99; i++) { 
    9. 
   
  
  
  
  9.             executor.submit(() -> { 
    10. 
   
  
  
  
  10.                 if (stock.get() < 0) { 
    11. 
   
  
  
  
  11.                     System.err.println("库存不足, 直接返回"); 
    12. 
   
  
  
  
  12.                     return; 
    13. 
   
  
  
  
  13.                 } 
    14. 
   
  
  
  
  14.                 try { 
    15. 
   
  
  
  
  15.                     boolean acquire = mutex.acquire(200, TimeUnit.MILLISECONDS); 
    16. 
   
  
  
  
  16.                     if (acquire) { 
    17. 
   
  
  
  
  17.                         int s = stock.decrementAndGet(); 
    18. 
   
  
  
  
  18.                         if (s < 0) { 
    19. 
   
  
  
  
  19.                             System.err.println("进入秒杀，库存不足"); 
    20. 
   
  
  
  
  20.                         } else { 
    21. 
   
  
  
  
  21.                             System.out.println("购买成功, 剩余库存: " + s); 
    22. 
   
  
  
  
  22.                         } 
    23. 
   
  
  
  
  23.                     } 
    24. 
   
  
  
  
  24.                 } catch (Exception e) { 
    25. 
   
  
  
  
  25.                     e.printStackTrace(); 
    26. 
   
  
  
  
  26.                 } finally { 
    27. 
   
  
  
  
  27.                     try { 
    28. 
   
  
  
  
  28.                         if (mutex.isAcquiredInThisProcess()) 
    29. 
   
  
  
  
  29.                             mutex.release(); 
    30. 
   
  
  
  
  30.                     } catch (Exception e) { 
    31. 
   
  
  
  
  31.                         e.printStackTrace(); 
    32. 
   
  
  
  
  32.                     } 
    33. 
   
  
  
  
  33.                 } 
    34. 
   
  
  
  
  34.             }); 
    35. 
   
  
  
  
  35.         } 
    36. 
   
  
  
  
  36.         while (true) { 
    37. 
   
  
  
  
  37.             if (executor.isTerminated()) { 
    38. 
   
  
  
  
  38.                 executor.shutdown(); 
    39. 
   
  
  
  
  39.                 System.out.println("秒杀完毕剩余库存为:" + stock.get()); 
    40. 
   
  
  
  
  40.             } 
    41. 
   
  
  
  
  41.             TimeUnit.MILLISECONDS.sleep(100); 
    42. 
   
  
  
  
  42.         } 
    43. 
   
  
  
  
  43.     } 
    44. 
   
  
  
  
  44.     private static CuratorFramework getZkClient() { 
    45. 
   
  
  
  
  45.         String zkServerAddress = "127.0.0.1:2181"; 
    46. 
   
  
  
  
  46.         ExponentialBackoffRetry retryPolicy = new ExponentialBackoffRetry(1000, 3, 5000); 
    47. 
   
  
  
  
  47.         CuratorFramework zkClient = CuratorFrameworkFactory.builder() 
    48. 
   
  
  
  
  48.                 .connectString(zkServerAddress) 
    49. 
   
  
  
  
  49.                 .sessionTimeoutMs(5000) 
    50. 
   
  
  
  
  50.                 .connectionTimeoutMs(5000) 
    51. 
   
  
  
  
  51.                 .retryPolicy(retryPolicy) 
    52. 
   
  
  
  
  52.                 .build(); 
    53. 
   
  
  
  
  53.         zkClient.start(); 
    54. 
   
  
  
  
  54.         return zkClient; 
    55. 
   
  
  
  
  55.     } 
    56. 
   
  
  
  
  56. } 
    57.

读写锁运用

读写锁可以用来保证缓存双写的强一致性的，因为读写锁在多线程读的时候是无锁的， 只有在前面有写锁的时候才会等待写锁完成后访问数据。

  
 
 
 
    
   
  
  
  
  1. public class ReadWriteLockTest { 
    2. 
   
  
  
  
  2.     static ExecutorService executor = Executors.newFixedThreadPool(8); 
    3. 
   
  
  
  
  3.     static AtomicInteger stock = new AtomicInteger(3); 
    4. 
   
  
  
  
  4.     static InterProcessMutex readLock; 
    5. 
   
  
  
  
  5.     static InterProcessMutex writeLock; 
    6. 
   
  
  
  
  6.     public static void main(String[] args) throws InterruptedException { 
    7. 
   
  
  
  
  7.         CuratorFramework client = getZkClient(); 
    8. 
   
  
  
  
  8.         String key = "/lock/lockId_111/1111"; 
    9. 
   
  
  
  
  9.         InterProcessReadWriteLock readWriteLock = new InterProcessReadWriteLock(client, key); 
    10. 
   
  
  
  
  10.         readLock = readWriteLock.readLock(); 
    11. 
   
  
  
  
  11.         writeLock = readWriteLock.writeLock(); 
    12. 
   
  
  
  
  12.         for (int i = 0; i < 16; i++) { 
    13. 
   
  
  
  
  13.             executor.submit(() -> { 
    14. 
   
  
  
  
  14.                 try { 
    15. 
   
  
  
  
  15.                     boolean read = readLock.acquire(2000, TimeUnit.MILLISECONDS); 
    16. 
   
  
  
  
  16.                     if (read) { 
    17. 
   
  
  
  
  17.                         int num = stock.get(); 
    18. 
   
  
  
  
  18.                         System.out.println("读取库存，当前库存为: " + num); 
    19. 
   
  
  
  
  19.                         if (num < 0) { 
    20. 
   
  
  
  
  20.                             System.err.println("库存不足, 直接返回"); 
    21. 
   
  
  
  
  21.                             return; 
    22. 
   
  
  
  
  22.                         } 
    23. 
   
  
  
  
  23.                     } 
    24. 
   
  
  
  
  24.                 } catch (Exception e) { 
    25. 
   
  
  
  
  25.                     e.printStackTrace(); 
    26. 
   
  
  
  
  26.                 }finally { 
    27. 
   
  
  
  
  27.                     if (readLock.isAcquiredInThisProcess()) { 
    28. 
   
  
  
  
  28.                         try { 
    29. 
   
  
  
  
  29.                             readLock.release(); 
    30. 
   
  
  
  
  30.                         } catch (Exception e) { 
    31. 
   
  
  
  
  31.                             e.printStackTrace(); 
    32. 
   
  
  
  
  32.                         } 
    33. 
   
  
  
  
  33.                     } 
    34. 
   
  
  
  
  34.                 } 
    35. 
   
  
  
  
  35.                 try { 
    36. 
   
  
  
  
  36.                     boolean acquire = writeLock.acquire(2000, TimeUnit.MILLISECONDS); 
    37. 
   
  
  
  
  37.                     if (acquire) { 
    38. 
   
  
  
  
  38.                         int s = stock.get(); 
    39. 
   
  
  
  
  39.                         if (s <= 0) { 
    40. 
   
  
  
  
  40.                             System.err.println("进入秒杀，库存不足"); 
    41. 
   
  
  
  
  41.                         } else { 
    42. 
   
  
  
  
  42.                             s = stock.decrementAndGet(); 
    43. 
   
  
  
  
  43.                             System.out.println("购买成功, 剩余库存: " + s); 
    44. 
   
  
  
  
  44.                         } 
    45. 
   
  
  
  
  45.                     } 
    46. 
   
  
  
  
  46.                 } catch (Exception e) { 
    47. 
   
  
  
  
  47.                     e.printStackTrace(); 
    48. 
   
  
  
  
  48.                 } finally { 
    49. 
   
  
  
  
  49.                     try { 
    50. 
   
  
  
  
  50.                         if (writeLock.isAcquiredInThisProcess()) 
    51. 
   
  
  
  
  51.                             writeLock.release(); 
    52. 
   
  
  
  
  52.                     } catch (Exception e) { 
    53. 
   
  
  
  
  53.                         e.printStackTrace(); 
    54. 
   
  
  
  
  54.                     } 
    55. 
   
  
  
  
  55.                 } 
    56. 
   
  
  
  
  56.             }); 
    57. 
   
  
  
  
  57.         } 
    58. 
   
  
  
  
  58.         while (true) { 
    59. 
   
  
  
  
  59.             if (executor.isTerminated()) { 
    60. 
   
  
  
  
  60.                 executor.shutdown(); 
    61. 
   
  
  
  
  61.                 System.out.println("秒杀完毕剩余库存为:" + stock.get()); 
    62. 
   
  
  
  
  62.             } 
    63. 
   
  
  
  
  63.             TimeUnit.MILLISECONDS.sleep(100); 
    64. 
   
  
  
  
  64.         } 
    65. 
   
  
  
  
  65.     } 
    66. 
   
  
  
  
  66.     private static CuratorFramework getZkClient() { 
    67. 
   
  
  
  
  67.         String zkServerAddress = "127.0.0.1:2181"; 
    68. 
   
  
  
  
  68.         ExponentialBackoffRetry retryPolicy = new ExponentialBackoffRetry(1000, 3, 5000); 
    69. 
   
  
  
  
  69.         CuratorFramework zkClient = CuratorFrameworkFactory.builder() 
    70. 
   
  
  
  
  70.                 .connectString(zkServerAddress) 
    71. 
   
  
  
  
  71.                 .sessionTimeoutMs(5000) 
    72. 
   
  
  
  
  72.                 .connectionTimeoutMs(5000) 
    73. 
   
  
  
  
  73.                 .retryPolicy(retryPolicy) 
    74. 
   
  
  
  
  74.                 .build(); 
    75. 
   
  
  
  
  75.         zkClient.start(); 
    76. 
   
  
  
  
  76.         return zkClient; 
    77. 
   
  
  
  
  77.     } 
    78. 
   
  
  
  
  78. } 
    79.

打印结果如下，一开始会有 8 个输出结果为 读取库存，当前库存为: 3 然后在写锁中回去顺序的扣减少库存。

  
 
 
 
    
   
  
  
  
  1. 读取库存，当前库存为: 3 
    2. 
   
  
  
  
  2. 读取库存，当前库存为: 3 
    3. 
   
  
  
  
  3. 读取库存，当前库存为: 3 
    4. 
   
  
  
  
  4. 读取库存，当前库存为: 3 
    5. 
   
  
  
  
  5. 读取库存，当前库存为: 3 
    6. 
   
  
  
  
  6. 读取库存，当前库存为: 3 
    7. 
   
  
  
  
  7. 读取库存，当前库存为: 3 
    8. 
   
  
  
  
  8. 读取库存，当前库存为: 3 
    9. 
   
  
  
  
  9. 购买成功, 剩余库存: 2 
    10. 
   
  
  
  
  10. 购买成功, 剩余库存: 1 
    11. 
   
  
  
  
  11. 购买成功, 剩余库存: 0 
    12. 
   
  
  
  
  12. 进入秒杀，库存不足 
    13. 
   
  
  
  
  13. 进入秒杀，库存不足 
    14. 
   
  
  
  
  14. 进入秒杀，库存不足 
    15. 
   
  
  
  
  15. 进入秒杀，库存不足 
    16. 
   
  
  
  
  16. 进入秒杀，库存不足 
    17. 
   
  
  
  
  17. 读取库存，当前库存为: 0 
    18. 
   
  
  
  
  18. 读取库存，当前库存为: 0 
    19. 
   
  
  
  
  19. 读取库存，当前库存为: 0 
    20. 
   
  
  
  
  20. 读取库存，当前库存为: 0 
    21. 
   
  
  
  
  21. 读取库存，当前库存为: 0 
    22. 
   
  
  
  
  22. 读取库存，当前库存为: 0 
    23. 
   
  
  
  
  23. 读取库存，当前库存为: 0 
    24. 
   
  
  
  
  24. 读取库存，当前库存为: 0 
    25. 
   
  
  
  
  25. 进入秒杀，库存不足 
    26. 
   
  
  
  
  26. 进入秒杀，库存不足 
    27. 
   
  
  
  
  27. 进入秒杀，库存不足 
    28. 
   
  
  
  
  28. 进入秒杀，库存不足 
    29. 
   
  
  
  
  29. 进入秒杀，库存不足 
    30. 
   
  
  
  
  30. 进入秒杀，库存不足 
    31. 
   
  
  
  
  31. 进入秒杀，库存不足 
    32. 
   
  
  
  
  32. 进入秒杀，库存不足 
    33.

分布式锁的选择

咱们最常用的就是 Redis 的分布式锁和 Zookeeper 的分布式锁，在性能方面 Redis 的每秒钟 TPS 可以上轻松上万。在大规模的高并发场景我推荐使用 Redis 分布式锁来作为推荐的技术方案。如果对并发要求不是特别高的场景可以使用 Zookeeper 分布式来处理。

参考资料

https://www.cnblogs.com/leeego-123/p/12162220.html

http://curator.apache.org/

https://blog.csdn.net/hosaos/article/details/89521537

分享文章：分布式锁看了又看，优秀方案我来告诉你
网页网址：http://www.shufengxianlan.com/qtweb/news39/276939.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

静态网站知识

分类信息网

复盛机电设备安装　　 　消防工程　　 　成都网站优化　　 　手机网站制作　　 　郫县明安消防器材　　 　四川服务器托管　　 　vi形象设计　　 　德阳机房　　 　手机网站建设套餐　　 　青羊区雕琢时光　　 　微信小程序　　 　雅安电信机房　　 　seo推广公司　　 　四川鸿达　　 　青年旅行社　　 　中国（西部）云计算中心　　 　四川白乌鱼　　 　铁科精智测控　　 　成都网站设计　　 　成都网站建设