多线程测试redisson实现分布式锁出现org.redisson.RedissonShutdownException: Redisson is shutdown。

起源：在使用Redisson实现分布式定时调度的过程中，遇到一个非常奇怪的问题：经过一些操作后，调度器会报一个莫名其妙的错误，status is shutdown，经过多次观察发现是在rancher平台重新发布Spring Boot项目后就会报这个错误，怀疑和Spring Boot优雅关闭有关系，所以进行一个追溯确认的过程。
image.png
Reids数据：
image.png
然后翻阅 RScheduledExecutorService 的方法，发现shutdown方法代码执行的 lua 脚本和目前看到的结果很相似，但是，身为程序员的我们是看证据的，没有证据都是耍流氓。
image.png
经过

方案1

尝试使用AOP拦截目标对象的方法，然后触发优雅关闭，看看是否能被拦截到，如果拦截到的话，它的调用栈信息也就随之出来了。

  1. import lombok.extern.slf4j.Slf4j;
  2. import org.aspectj.lang.ProceedingJoinPoint;
  3. import org.aspectj.lang.annotation.Around;
  4. import org.aspectj.lang.annotation.Aspect;
  5. import org.aspectj.lang.annotation.Pointcut;
  7. @Slf4j
  8. @Aspect
  9. public class ExecutorServiceAspect {
  11.     //定义切点
  12.     @Pointcut("execution(public * org.redisson.*.*(..))")
  13.     public void pointCut(){}
  15.     // 抛异常
  16.     @Around("pointCut()")
  17.     public Object aroundMethod(ProceedingJoinPoint pjd) throws Throwable {
  18.         log.info("invoke method. {}", pjd.getTarget());
  20.         throw new RuntimeException("切点被捕捉到！");
  21.     }
  22. }

然后调用使用postman调用http://127.0.0.1:8080/actuator/shutdown，实现优雅关闭，但是多次尝试，改变切点信息，发现都不能切到对象。后来仔细想了想，这个对象被代理了，甚至多层代理，肯定切不到这个对象的实际操作，所以这个方案失败。

方案2

在Redisson包中的shutdown等方法入口，尝试搜索一下调用关系。
通过schedule方法作为入口，看看能否找到一些线索。
image.png
发现大致经过以下几个流程：
image.png
并没有太大的参考价值，所以这个方案也有点行不通。

方案3

因为对象是在Spring 容器平缓关闭的时候触发的shutdown操作，而在Spring中每一个对象都是一个bean，bean 的生命周期中有一个destory的过程，所以可以基本断定是destory方法中执行了shutdown方法，并且RScheduledExecutorService是实现了java中的ExecutorService接口，而这个接口中定义了shutdown方法，而Spring可能使用ExecutorService统一管理这些bean。
DisposableBean这个接口定义的destory方法，是Spring bean生命周期中的一个方法，通过查看他的实现发现有一个可疑的对象 TaskExecutorFactoryBean
image.png
通过查看源码发现，其中确实调用了shutdown方法。
image.png
而这个executor对象，实际就是ExecutorService这个接口
image.png
就在这一刻，突然感觉真相大白了，终于找到证据了，所以可以确信是Spring Boot的平缓关闭导致的这个问题
小总结
通过本次追溯源码确实看到了许多大佬们设计这个框架的思想，特别是Spring设计的巧妙之处，使用这个统一的方式管理了Spring bean对象。

原因：多线程还没跑完，主线程就跑完了。主线程走完，关闭了资源。redisson关闭，
多线程操作redisson报错：Redisson is shutdown。
解决办法：主线程等待多线程跑完。Thread.sleep(30000);。

  1. package com.user.test.spring_redis;
  3. import java.util.HashSet;
  4. import java.util.Iterator;
  5. import java.util.Set;
  7. import org.junit.Test;
  8. import org.junit.runner.RunWith;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.test.context.ContextConfiguration;
  11. import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
  12. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  14. import com.user.service.redis.SecondKillService;
  15. import com.user.service.redis.SecondKillServiceImp;
  16. import com.user.service.redis.SecondKillThread;
  18. @RunWith(SpringJUnit4ClassRunner.class) 
  19. @ContextConfiguration({"classpath:applicationContext.xml"})
  20. public class RedisDistributedLockTest extends AbstractJUnit4SpringContextTests{
  21.     @Autowired
  22.     private SecondKillService secondKillService;
  23.     @Autowired
  24.     private SecondKillThread secondKillThread;
  26.     /**
  27.      * 模拟秒杀
  28.      */
  29.     @Test
  30.     public void secKill(){
  31.         System.out.println("秒杀活动开始---");
  32.         try {
  33.             for(int i=0;i<2000;i++){
  34.                 new Thread(secondKillThread,"Thread" + i).start();
  35.             }
  36.         } catch (Exception e) {
  37.             e.printStackTrace();
  38.         }
  39.         try {
  40.             // 主线程需要等待线程执行完，否则，其他线程还没执行完，主线程就走完了，redisson会报错：Redisson is shutdown
  41.             Thread.sleep(30000);
  42.         } catch (InterruptedException e1) {
  43.             e1.printStackTrace();
  44.         }
  45.         System.out.println(SecondKillServiceImp.list);
  46.         Set set = new HashSet();
  47.         for(int i : SecondKillServiceImp.list){
  48.             int count = 0;
  49.             for(int j : SecondKillServiceImp.list){
  50.                 if(i == j){
  51.                     count = count + 1;
  52.                 }
  53.             }
  54.             if(count > 1){
  55.                 set.add(i);
  56.             }
  57.         }
  58.         if(set != null && set.size() > 0){
  59. //            Iterator it = set.iterator();
  60. //            while(it.hasNext()){
  61. //                System.out.println(it.next());
  62. //            }
  63.             System.out.println(set);
  64.         }else{
  65.             System.out.println("没有重复的记录！");
  66.         }
  67.     }
  68. }
  1. package com.user.service.redis;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.stereotype.Component;
  6. @Component
  7. public class SecondKillThread implements Runnable{
  8.     @Autowired
  9.     private SecondKillService secondKillService;
  11.     @Override
  12.     public void run() {
  13.         secondKillService.seckill();
  14.     }
  15. }
  1. package com.user.service.redis;
  3. public interface SecondKillService {
  4.     public void seckill();
  5. }
  1. package com.user.service.redis;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.concurrent.TimeUnit;
  7. import org.apache.commons.lang3.StringUtils;
  8. import org.redisson.api.RLock;
  9. import org.redisson.api.RedissonClient;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.stereotype.Service;
  13. import com.user.base.utils.redis.DistributedLockUtils;
  14. import com.user.base.utils.redis.DistributedLockUtils2;
  15. import com.user.base.utils.redis.redisson.RedissonConfig;
  17. @Service
  18. public class SecondKillServiceImp implements SecondKillService{
  19.     @Autowired
  20.     private RedissonClient redissonClient;
  21.     private static int count = 2000;
  22.     public static List<Integer> list = new ArrayList<>();
  24.     @Override
  25.     public void seckill() {
  26. //        count = count - 1;
  27. //        list.add(count);
  28. //        System.out.println(Thread.currentThread().getName() + "秒杀操作,singleRedis," + "剩余数量：" + count);
  29.         // 可以防止重复提交的数据。
  30.         String uuid = DistributedLockUtils2.lockWithTimeout("test", 10);
  31.         // 上锁，如果锁一直保持，其他线程无法操作，只有过期或者主动释放锁。
  32.         if(StringUtils.isNotEmpty(uuid)){
  33.             try {
  34.                 count = count - 1;
  35.                 list.add(count);
  36.                 System.out.println(Thread.currentThread().getName() + "秒杀操作,singleRedis," + "剩余数量：" + count);
  37.             } catch (Exception e) {
  38.                 //e.printStackTrace();
  39.             } finally {
  40.                 // 如果业务代码出现异常了，不在finally中执行释放锁的操作，也会导致锁无法释放。
  41.                 DistributedLockUtils2.releaseLock("test",uuid);
  42.             }
  43.         }else{
  44.             System.out.println("获取锁超时！");
  45.         }
  46.     }
  48. //    @Override
  49. //    public void seckill() {
  50. //        RLock redissonLock = redissonClient.getLock("test");
  51. //        // 相当于distributedLockUtil.stringRedisTemplate.opsForValue().setIfAbsent(lockKey, identifier, timeout, TimeUnit.SECONDS)
  52. //        redissonLock.lock();
  53. //        try {
  54. //            count = count - 1;
  55. //            list.add(count);
  56. //            System.out.println(Thread.currentThread().getName() + "秒杀操作,clusterRedis," + "剩余数量：" + count);
  57. //        } catch (Exception e) {
  58. //            e.printStackTrace();
  59. //        } finally {
  60. //            // 相当于distributedLockUtil.stringRedisTemplate.delete(lockKey);
  61. //            /*
  62. //             * 由于开启了watchdog看门狗线程监听，所以线程执行完之前不会出现：A线程锁过期时间过期，此时B线程设置锁，然后又切换到A线程删锁，误删B线程的锁。
  63. //             * 因为A线程执行完之前，A线程的锁会一直续命，不会过期。所以A线程在delete锁之前，会一直持有锁。
  64. //             * 如果服务器非宕机情况，那么锁会一直续命，A线程一直持有锁。最终都会执行到finally释放锁。
  65. //             * 如果中间出现宕机，那么锁不会续命，到了过期时间就会过期。锁自动释放。
  66. //             * 因此不会出现锁无法释放，死锁的情况。
  67. //             * 
  68. //             * 自己写续命比较麻烦，而且容易出错。redisson是个很好的框架和解决方案。
  69. //             */
  70. //            redissonLock.unlock();
  71. //        }
  72. //    }
  73. }

参考：https://github.com/redisson/redisson/issues/1872