手把手教你 SpringBoot 分布式锁的实现

你知道的越多，不知道的就越多，业余的像一棵小草！

你来，我们一起精进！你不来，我和你的竞争对手一起精进！

编辑：业余草

来源：https:///632yIv

推荐：https://www./?p=5035

前言

前段时间面试了一个高级程序员，问他了一些分布式锁的知识，回答的还不错。后来进了我们的团队，刚好让他接手一个新项目，需要用到分布式锁，我说这是你的强项，你来实现。

谁知，项目上线后，各种问题接连爆发出来。后来我找他谈话，主要是说，千万不要重复造轮子，直接吧 A 项目中的 Redisson 用法实现复制过来一份不就行了，干嘛非要自己搞一套，还搞出问题。。。

今天，我们一起来手把手来实现一个高效的 SpringBoot 分布式锁！本文通过 Spring Boot 整合 redisson 来实现分布式锁，并结合 demo 测试结果。

分析设计要点

当我们在设计分布式锁的时候，我们应该考虑分布式锁至少要满足的一些条件，同时考虑如何高效的设计分布式锁，这里我认为以下几点是必须要考虑的。

1、互斥

在分布式高并发的条件下，我们最需要保证，同一时刻只能有一个线程获得锁，这是最基本的一点。

2、防止死锁

在分布式高并发的条件下，比如有个线程获得锁的同时，还没有来得及去释放锁，就因为系统故障或者其它原因使它无法执行释放锁的命令,导致其它线程都无法获得锁，造成死锁。

所以分布式非常有必要设置锁的有效时间，确保系统出现故障后，在一定时间内能够主动去释放锁，避免造成死锁的情况。

3、性能

对于访问量大的共享资源，需要考虑减少锁等待的时间，避免导致大量线程阻塞。

所以在锁的设计时，需要考虑两点。

1、锁的颗粒度要尽量小。比如你要通过锁来减库存，那这个锁的名称你可以设置成是商品的ID,而不是任取名称。这样这个锁只对当前商品有效,锁的颗粒度小。

2、锁的范围尽量要小。比如只要锁2行代码就可以解决问题的，那就不要去锁10行代码了。

4、重入

我们知道ReentrantLock是可重入锁，那它的特点就是：同一个线程可以重复拿到同一个资源的锁。重入锁非常有利于资源的高效利用。关于这点之后会做演示。

针对以上Redisson都能很好的满足，下面就来使用它。

首先看下常规Redis锁的处理图

代码实现

添加依赖

1. <!--redis-->

2. <dependency>

1. <groupId>org.springframework.boot</groupId>

2. <artifactId>spring-boot-starter-data-redis</artifactId>

3. </dependency>

4. <!--redisson-->

5. <dependency>

1. <groupId>org.redisson</groupId>

2. <artifactId>redisson-spring-boot-starter</artifactId>

3. <version>3.10.6</version>

6. </dependency>

配置信息

spring:
# redis
  redis:
    host: 47.103.5.190
    port: 6379
    jedis:
      pool:
# 连接池最大连接数（使用负值表示没有限制）
        max-active: 100
# 连接池中的最小空闲连接
        max-idle: 10
# 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1
# 连接超时时间（毫秒）
      timeout: 5000
#默认是索引为0的数据库
      database: 0

配置类

1. /**

2. * redisson 配置，下面是单节点配置：

3. *

4. * @author gourd

5. */

6. @Configuration

7. publicclassRedissonConfig{

8. @Value('${spring.redis.host}')

9. privateString host;

10. @Value('${spring.redis.port}')

11. privateString port;

12. @Value('${spring.redis.password:}')

13. privateString password;

15. @Bean

16. publicRedissonClient redissonClient() {

17. Config config = newConfig();

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. returnRedisson.create(config);

30. }

31. }

Redisson 工具类

/**
 * redis分布式锁帮助类
 *
 * @author gourd
 *
 */
publicclassRedisLockUtil{
privatestaticDistributedLocker distributedLocker = SpringContextHolder.getBean('distributedLocker',DistributedLocker.class);
/**
     * 加锁
     * @param lockKey
     * @return
     */
publicstaticRLocklock(String lockKey) {
return distributedLocker.lock(lockKey);
}
/**
     * 释放锁
     * @param lockKey
     */
publicstaticvoid unlock(String lockKey) {
        distributedLocker.unlock(lockKey);
}
/**
     * 释放锁
     * @param lock
     */
publicstaticvoid unlock(RLocklock) {
        distributedLocker.unlock(lock);
}
/**
     * 带超时的锁
     * @param lockKey
     * @param timeout 超时时间   单位：秒
     */
publicstaticRLocklock(String lockKey, int timeout) {
return distributedLocker.lock(lockKey, timeout);
}
/**
     * 带超时的锁
     * @param lockKey
     * @param unit 时间单位
     * @param timeout 超时时间
     */
publicstaticRLocklock(String lockKey, int timeout,TimeUnit unit ) {
return distributedLocker.lock(lockKey, unit, timeout);
}
/**
     * 尝试获取锁
     * @param lockKey
     * @param waitTime 最多等待时间
     * @param leaseTime 上锁后自动释放锁时间
     * @return
     */
publicstaticboolean tryLock(String lockKey, int waitTime, int leaseTime) {
return distributedLocker.tryLock(lockKey, TimeUnit.SECONDS, waitTime, leaseTime);
}
/**
     * 尝试获取锁
     * @param lockKey
     * @param unit 时间单位
     * @param waitTime 最多等待时间
     * @param leaseTime 上锁后自动释放锁时间
     * @return
     */
publicstaticboolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
return distributedLocker.tryLock(lockKey, unit, waitTime, leaseTime);
}
/**
     * 获取计数器
     *
     * @param name
     * @return
     */
publicstaticRCountDownLatch getCountDownLatch(String name){
return distributedLocker.getCountDownLatch(name);
}
/**
     * 获取信号量
     *
     * @param name
     * @return
     */
publicstaticRSemaphore getSemaphore(String name){
return distributedLocker.getSemaphore(name);
}
}

底层封装

1. /**

2. * @author gourd

3. */

4. publicinterfaceDistributedLocker{

6. RLocklock(String lockKey);

8. RLocklock(String lockKey, int timeout);

10. RLocklock(String lockKey, TimeUnit unit, int timeout);

12. boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime);

14. void unlock(String lockKey);

16. void unlock(RLocklock);

17. }

19. /**

20. * @author gourd

21. */

22. @Component

23. publicclassRedisDistributedLockerimplementsDistributedLocker{

25. @Autowired

26. privateRedissonClient redissonClient;

28. @Override

29. publicRLocklock(String lockKey) {

30. RLocklock= redissonClient.getLock(lockKey);

31. lock.lock();

32. returnlock;

33. }

35. @Override

36. publicRLocklock(String lockKey, int leaseTime) {

37. RLocklock= redissonClient.getLock(lockKey);

38. lock.lock(leaseTime, TimeUnit.SECONDS);

39. returnlock;

40. }

42. @Override

43. publicRLocklock(String lockKey, TimeUnit unit ,int timeout) {

44. RLocklock= redissonClient.getLock(lockKey);

45. lock.lock(timeout, unit);

46. returnlock;

47. }

49. @Override

50. publicboolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {

51. RLocklock= redissonClient.getLock(lockKey);

52. try{

53. returnlock.tryLock(waitTime, leaseTime, unit);

54. } catch(InterruptedException e) {

55. returnfalse;

56. }

57. }

59. @Override

60. publicvoid unlock(String lockKey) {

61. RLocklock= redissonClient.getLock(lockKey);

62. lock.unlock();

63. }

65. @Override

66. publicvoid unlock(RLocklock) {

67. lock.unlock();

68. }

69. }

测试

模拟并发测试

/**
 * redis分布式锁控制器
 * @author gourd
 * @since 2019-07-30
 */
@RestController
@Api(tags = 'redisson', description = 'redis分布式锁控制器')
@RequestMapping('/redisson')
@Slf4j
publicclassRedissonLockController{
/**
     * 锁测试共享变量
     */
privateInteger lockCount = 10;
/**
     * 无锁测试共享变量
     */
privateInteger count = 10;
/**
     * 模拟线程数
     */
privatestaticint threadNum = 10;
/**
     * 模拟并发测试加锁和不加锁
     * @return
     */
@GetMapping('/test')
@ApiOperation(value = '模拟并发测试加锁和不加锁')
publicvoidlock(){
// 计数器
finalCountDownLatch countDownLatch = newCountDownLatch(1);
for(int i = 0; i < threadNum; i ++) {
MyRunnable myRunnable = newMyRunnable(countDownLatch);
Thread myThread = newThread(myRunnable);
            myThread.start();
}
// 释放所有线程
        countDownLatch.countDown();
}
/**
     * 加锁测试
     */
privatevoid testLockCount() {
String lockKey = 'lock-test';
try{
// 加锁，设置超时时间2s
RedisLockUtil.lock(lockKey,2, TimeUnit.SECONDS);
            lockCount--;
            log.info('lockCount值：'+lockCount);
}catch(Exception e){
            log.error(e.getMessage(),e);
}finally{
// 释放锁
RedisLockUtil.unlock(lockKey);
}
}
/**
     * 无锁测试
     */
privatevoid testCount() {
        count--;
        log.info('count值：'+count);
}
publicclassMyRunnableimplementsRunnable{
/**
         * 计数器
         */
finalCountDownLatch countDownLatch;
publicMyRunnable(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
}
@Override
publicvoid run() {
try{
// 阻塞当前线程，直到计时器的值为0
                countDownLatch.await();
} catch(InterruptedException e) {
                log.error(e.getMessage(),e);
}
// 无锁操作
            testCount();
// 加锁操作
            testLockCount();
}
}
}

调用接口后打印值：

测试结果

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

本文只是实战项目中复制出来的部分代码，实际使用中封装成了 jar，内部系统只需要引用即可。最后，希望对大家有帮助。如有错误之处，欢迎指正！