Spring Boot 分布式锁的实现

灰太狼 2020-05-25 06:02 1034阅读 2赞

Spring Boot 分布式锁的实现

前言

面试总是会被问到有没有用过分布式锁、redis 锁，大部分读者平时很少接触到，所以只能很无奈的回答 “没有”。本文通过 Spring Boot 整合 redisson 来实现分布式锁，并结合 demo 测试结果。

首先看下大佬总结的图

正文

添加依赖

  1. <!--redis-->
  2. <dependency>
  3.     <groupId>
  4.         org.springframework.boot
  5.     </groupId>
  6.     <artifactId>
  7.         spring-boot-starter-data-redis
  8.     </artifactId>
  9. </dependency>
  10. <!--redisson-->
  11. <dependency>
  12.     <groupId>
  13.         org.redisson
  14.     </groupId>
  15.     <artifactId>
  16.         redisson-spring-boot-starter
  17.     </artifactId>
  18.     <version>
  19.         3.10.6
  20.     </version>
  21. </dependency>

配置信息

  1. spring:
  2.   # redis
  3.   redis:
  4.     host: 47.103.5.190
  5.     port: 6379
  6.     jedis:
  7.       pool:
  8.         # 连接池最大连接数（使用负值表示没有限制）
  9.         max-active: 100
  10.         # 连接池中的最小空闲连接
  11.         max-idle: 10
  12.         # 连接池最大阻塞等待时间（使用负值表示没有限制）
  13.         max-wait: -1
  14.         # 连接超时时间（毫秒）
  15.         timeout: 5000
  16.         #默认是索引为0的数据库
  17.         database: 0

配置类

  1. /**
  2.  * redisson 配置，下面是单节点配置：
  3.  *
  4.  * @author gourd
  5.  */
  6. @Configuration
  7. public class RedissonConfig {
  8.     @Value("${spring.redis.host}")
  9.     private String host;
  10.     @Value("${spring.redis.port}")
  11.     private String port;
  12.     @Value("${spring.redis.password:}")
  13.     private String password;
  15.     @Bean
  16.     public RedissonClient redissonClient() {
  17.         Config config = new Config();
  18.         //单节点
  19.         config.useSingleServer().setAddress("redis://" + host + ":" + port);
  20.         if (StringUtils.isEmpty(password)) {
  21.             config.useSingleServer().setPassword(null);
  22.         } else {
  23.             config.useSingleServer().setPassword(password);
  24.         }
  25.         //添加主从配置
  26.         // config.useMasterSlaveServers().setMasterAddress("").setPassword("").addSlaveAddress(new String[]{"",""});
  27.         // 集群模式配置 setScanInterval()扫描间隔时间，单位是毫秒, //可以用"rediss://"来启用SSL连接
  28.         // config.useClusterServers().setScanInterval(2000).addNodeAddress("redis://127.0.0.1:7000", "redis://127.0.0.1:7001").addNodeAddress("redis://127.0.0.1:7002");
  29.         return Redisson.create(config);
  30.     }
  31. }

Redisson 工具类

  1. /**
  2.  * redis分布式锁帮助类
  3.  *
  4.  * @author gourd
  5.  */
  6. public class RedisLockUtil {
  8.     private static DistributedLocker distributedLocker = SpringContextHolder.getBean("distributedLocker", DistributedLocker.class);
  10.     /**
  11.      * 加锁
  12.      *
  13.      * @param lockKey
  14.      * @return
  15.      */
  16.     public static RLock lock(String lockKey) {
  17.         return distributedLocker.lock(lockKey);
  18.     }
  20.     /**
  21.      * 释放锁
  22.      *
  23.      * @param lockKey
  24.      */
  25.     public static void unlock(String lockKey) {
  26.         distributedLocker.unlock(lockKey);
  27.     }
  29.     /**
  30.      * 释放锁
  31.      *
  32.      * @param lock
  33.      */
  34.     public static void unlock(RLock lock) {
  35.         distributedLocker.unlock(lock);
  36.     }
  38.     /**
  39.      * 带超时的锁
  40.      *
  41.      * @param lockKey
  42.      * @param timeout 超时时间   单位：秒
  43.      */
  44.     public static RLock lock(String lockKey, int timeout) {
  45.         return distributedLocker.lock(lockKey, timeout);
  46.     }
  48.     /**
  49.      * 带超时的锁
  50.      *
  51.      * @param lockKey
  52.      * @param unit    时间单位
  53.      * @param timeout 超时时间
  54.      */
  55.     public static RLock lock(String lockKey, int timeout, TimeUnit unit) {
  56.         return distributedLocker.lock(lockKey, unit, timeout);
  57.     }
  59.     /**
  60.      * 尝试获取锁
  61.      *
  62.      * @param lockKey
  63.      * @param waitTime  最多等待时间
  64.      * @param leaseTime 上锁后自动释放锁时间
  65.      * @return
  66.      */
  67.     public static boolean tryLock(String lockKey, int waitTime, int leaseTime) {
  68.         return distributedLocker.tryLock(lockKey, TimeUnit.SECONDS, waitTime, leaseTime);
  69.     }
  71.     /**
  72.      * 尝试获取锁
  73.      *
  74.      * @param lockKey
  75.      * @param unit      时间单位
  76.      * @param waitTime  最多等待时间
  77.      * @param leaseTime 上锁后自动释放锁时间
  78.      * @return
  79.      */
  80.     publicstaticboolean
  81.     tryLock(
  82.             String
  83.                     lockKey,
  84.             TimeUnit
  85.                     unit,
  86.             int
  87.                     waitTime,
  88.             int
  89.                     leaseTime) {
  90.         return
  91.                 distributedLocker.tryLock(lockKey, unit, waitTime, leaseTime);
  92.     }
  94.     /**
  95.      * 获取计数器
  96.      *
  97.      * @param name
  98.      * @return
  99.      */
  100.     public static RCountDownLatch getCountDownLatch(String name) {
  101.         return distributedLocker.getCountDownLatch(name);
  102.     }
  104.     /**
  105.      * 获取信号量
  106.      *
  107.      * @param name
  108.      * @return
  109.      */
  110.     public static RSemaphore getSemaphore(String name) {
  111.         return distributedLocker.getSemaphore(name);
  112.     }
  113. }

底层封装

  1. /**
  2.  * @author gourd
  3.  */
  4. public interface DistributedLocker {
  5.     RLock lock(String lockKey);
  7.     RLock lock(String lockKey, int timeout);
  9.     RLock lock(String lockKey, TimeUnit unit, int timeout);
  11.     boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime);
  13.     void unlock(String lockKey);
  15.     void unlock(RLock lock);
  16. }
  18. /**
  19.  * @author gourd
  20.  */
  21. @Component
  22. public class RedisDistributedLocker implements DistributedLocker {
  23.     @Autowired
  24.     private
  25.     RedissonClient redissonClient;
  27.     @Override
  28.     public RLock lock(String lockKey) {
  29.         RLock lock = redissonClient.getLock(lockKey);
  30.         lock.lock();
  31.         return lock;
  32.     }
  34.     @Override
  35.     public RLock lock(String lockKey, int leaseTime) {
  36.         RLock lock = redissonClient.getLock(lockKey);
  37.         lock.lock(leaseTime, TimeUnit.SECONDS);
  38.         return lock;
  39.     }
  41.     @Override
  42.     public RLock lock(String lockKey, TimeUnit unit, int timeout) {
  43.         RLock lock = redissonClient.getLock(lockKey);
  44.         lock.lock(timeout, unit);
  45.         return lock;
  46.     }
  48.     @Override
  49.     public boolean
  50.     tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
  51.         RLock lock = redissonClient.getLock(lockKey);
  52.         try {
  53.             return lock.tryLock(waitTime, leaseTime, unit);
  54.         } catch (InterruptedException e) {
  55.             return false;
  56.         }
  57.     }
  59.     @Override
  60.     public void
  61.     unlock(String lockKey) {
  62.         RLock lock = redissonClient.getLock(lockKey);
  63.         lock.unlock();
  64.     }
  66.     @Override
  67.     public void
  68.     unlock(RLock lock) {
  69.         lock.unlock();
  70.     }
  71. }

测试

模拟并发测试

  1. /**
  2.  * redis分布式锁控制器
  3.  *
  4.  * @author gourd
  5.  * @since 2019-07-30
  6.  */
  7. @RestController
  8. @Api(tags = "redisson", description = "redis分布式锁控制器")
  9. @RequestMapping("/redisson")
  10. @Slf4j
  11. public class RedissonLockController {
  13.     /**
  14.      * 锁测试共享变量
  15.      */
  16.     private Integer lockCount = 10;
  18.     /**
  19.      * 无锁测试共享变量
  20.      */
  21.     private Integer count = 10;
  23.     /**
  24.      * 模拟线程数
  25.      */
  26.     private static int hreadNum = 10;
  28.     /**
  29.      * 模拟并发测试加锁和不加锁
  30.      *
  31.      * @return
  32.      */
  33.     @GetMapping("/test")
  34.     @ApiOperation(value = "模拟并发测试加锁和不加锁")
  35.     public void lock() {
  36.         // 计数器
  37.         final CountDownLatch countDownLatch = new CountDownLatch(1);
  38.         for (int i = 0; i < threadNum; i++) {
  39.             MyRunnable myRunnable = new MyRunnable(countDownLatch);
  40.             Thread myThread = new Thread(myRunnable);
  41.             myThread.start();
  42.         }
  43.         // 释放所有线程
  44.         countDownLatch.countDown();
  45.     }
  47.     /**
  48.      * 加锁测试
  49.      */
  50.     private void testLockCount() {
  51.         String lockKey = "lock-test";
  52.         try {
  53.             // 加锁，设置超时时间2s
  54.             RedisLockUtil.lock(lockKey, 2, TimeUnit.SECONDS);
  55.             lockCount--;
  56.             log.info("lockCount值：" + lockCount);
  57.         } catch (Exception e) {
  58.             log.error(e.getMessage(), e);
  59.         } finally {
  60.             // 释放锁
  61.             RedisLockUtil.unlock(lockKey);
  62.         }
  63.     }
  65.     /**
  66.      * 无锁测试
  67.      */
  68.     private void testCount() {
  69.         count--;
  70.         log.info("count值：" + count);
  71.     }
  74.     public class MyRunnable implements Runnable {
  75.         /**
  76.          * 计数器
  77.          */
  78.         final CountDownLatch countDownLatch;
  80.         public MyRunnable(CountDownLatch countDownLatch) {
  81.             this.countDownLatch = countDownLatch;
  82.         }
  84.         @Override
  85.         public void run() {
  86.             try {
  87.                 // 阻塞当前线程，直到计时器的值为0
  88.                 countDownLatch.await();
  89.             } catch (InterruptedException e) {
  90.                 log.error(e.getMessage(), e);
  91.             }
  92.             // 无锁操作
  93.             testCount();
  94.             // 加锁操作
  95.             testLockCount();
  96.         }
  98.     }
  100. }

调用接口后打印值：

测试结果

根据打印结果可以明显看到，未加锁的 count— 后值是乱序的，而加锁后的结果和我们预期的一样。

由于条件问题没办法测试分布式的并发。只能模拟单服务的这种并发，但是原理是一样，希望对大家有帮助。如有错误之处，欢迎指正。

发表评论

表情：
评论列表 （有 0 条评论，1034人围观）

还没有评论，来说两句吧...

相关阅读

    相关 spring boot redis分布式锁

    随着现在分布式架构越来越盛行，在很多场景下需要使用到分布式锁。分布式锁的实现有很多种，比如基于[数据库][Link 1]、zookeeper等，本文主要介绍使用Redis做分布

    梦里梦外;梦里梦外;/ 0 赞/ 139 阅读