需求

  1. 互斥性：只有一个客户端能持有锁
  2. 不死锁：保证后续客户端加锁
  3. 容错性：大部分redis节点正常运行，客户端就可以加锁解锁
  4. 阻塞性：其他客户端尝试请求锁的时间内阻塞状态
  5. 可重入性：在锁里面加锁
  6. 不能自己失效：在业务执行过程中，锁不能自己失效（异步续命）
  7. 解铃还须系铃人：持有锁的线程才能解自己上的锁

Redisson框架很好的实现

Java手写实现

基于spring整合的redisTemplate对redis进行操作
使用异步任务线程池ScheduledThreadPoolExecutor进行异步续命

  1. @Slf4j
  2. public class RedisLock {
  4.     private RedisTemplate<String, String> redisTemplate;
  6.     /**
  7.      * 避免自己的锁被别的线程释放了
  8.      */
  9.     private final ThreadLocal<String> local = new ThreadLocal<>();
  11.     /**
  12.      * 用于实现可重入锁
  13.      */
  14.     private final ThreadLocal<Integer> reentrant = new ThreadLocal<>();
  16.     /**
  17.      * 分布式锁key前缀
  18.      */
  19.     private static final String PREFIX = "LOCK_";
  21.     private String lockKey;
  23.     /**
  24.      * 用于异步续命的对象
  25.      */
  26.     private RenewLockTimes renewLockTimes;
  28.     /**
  29.      * 创建锁对象
  30.      *
  31.      * @param key           要锁的key
  32.      * @param redisTemplate
  33.      * @author YangYudi
  34.      * @date 2021/10/29 9:49
  35.      */
  36.     public RedisLock(String key, RedisTemplate<String, String> redisTemplate) {
  37.         this.lockKey = PREFIX + key;
  38.         this.redisTemplate = redisTemplate;
  39.     }
  41.     /**
  42.      * 加锁
  43.      *
  44.      * @param tryTime 尝试时间 单位秒
  45.      * @param timeout 锁时间 单位秒
  46.      * @return java.lang.Boolean
  47.      * @author YangYudi
  48.      * @date 2021/10/29 9:49
  49.      */
  50.     public Boolean tryLock(long tryTime, long timeout) {
  51.         long startTime = System.currentTimeMillis();
  52.         //确保本线程的值唯一
  53.         String uuid = UUID.randomUUID().toString();
  54.         Boolean lock = false;
  56.         if (StringUtils.isEmpty(local.get())) {
  57.             //每个线程的value都不一样
  58.             //使用threadLocal保证线程安全
  59.             local.set(uuid);
  60.             lock = redisTemplate.opsForValue().setIfAbsent(lockKey, uuid, timeout, TimeUnit.SECONDS);
  61.             //没拿到锁就阻塞 自旋锁 直到拿到锁就不阻塞
  62.             while (lock != null && !lock) {
  63.                 lock = redisTemplate.opsForValue().setIfAbsent(lockKey, uuid, timeout, TimeUnit.SECONDS);
  64.                 //超时就直接返回false
  65.                 if (System.currentTimeMillis() - startTime >= (tryTime * 1000)) {
  66.                     log.error("{} 放弃拿到锁", lockKey);
  67.                     break;
  68.                 }
  69.             }
  70.             if (lock != null && lock) {
  71.                 //得到锁了 开启异步续命
  72.                 renewLockTimes = new RenewLockTimes(lockKey, timeout, redisTemplate);
  73.                 renewLockTimes.schedule();
  74.             }
  75.         } else {
  76.             //可重入性
  77.             lock = true;
  78.         }
  79.         //可重入锁
  80.         //加锁成功后计数器加一
  81.         if (lock != null && lock) {
  82.             Integer count = reentrant.get() == null ? 0 : reentrant.get();
  83.             reentrant.set(++count);
  84.             log.info("加锁成功,{}", lockKey);
  85.         }
  86.         return lock;
  87.     }
  89.     /**
  90.      * 加锁
  91.      *
  92.      * @param tryTime
  93.      * @return java.lang.Boolean
  94.      * @author YangYudi
  95.      * @date 2021/10/29 9:49
  96.      */
  97.     public Boolean tryLock(long tryTime) {
  98.         return tryLock(tryTime, 10);
  99.     }
  101.     /**
  102.      * 加锁
  103.      *
  104.      * @return java.lang.Boolean
  105.      * @author YangYudi
  106.      * @date 2021/10/29 9:49
  107.      */
  108.     public Boolean tryLock() {
  109.         return tryLock(5, 10);
  110.     }
  112.     /**
  113.      * 释放锁
  114.      *
  115.      * @return java.lang.Boolean
  116.      * @author YangYudi
  117.      * @date 2021/10/29 9:49
  118.      */
  119.     public void releaseLock() {
  120.         //get和delete是两个方法 没有原子性 如果不用lua脚本 就需要用到监听和事务来完成
  121.         //保证本线程的锁只能被本线程释放
  122.         //先判断锁是不是本线程的 如果是就删除key返回1 否则返回 0
  123.         String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
  124.                 "then\n" +
  125.                 "    return redis.call(\"del\",KEYS[1])\n" +
  126.                 "else\n" +
  127.                 "    return 0\n" +
  128.                 "end";
  129.         Integer count = reentrant.get();
  130.         if (count == null || count - 1 <= 0) {
  131.             RedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
  132.             //执行lua脚本 只有当前线程才能释放锁
  133.             Long execute = redisTemplate.execute(redisScript, Collections.singletonList(lockKey), local.get());
  134.             if (!ObjectUtils.isEmpty(execute) && execute == 1) {
  135.                 //锁释放
  136.                 log.info("{} 锁释放", lockKey);
  137.                 //结束续命
  138.                 renewLockTimes.shutdown();
  139.                 local.remove();
  140.                 reentrant.remove();
  141.             }
  142.         } else {
  143.             //可重入锁 加几次就要解几次锁
  144.             reentrant.set(--count);
  145.         }
  147.     }
  149.     private static class RenewLockTimes {
  151.         private String key;
  153.         private long timeout;
  155.         /**
  156.          * 续命的时间
  157.          */
  158.         private long plusTime;
  160.         private RedisTemplate<String, String> redisTemplate;
  162.         private ScheduledExecutorService service;
  164.         public RenewLockTimes(String key, long timeout, RedisTemplate<String, String> redisTemplate) {
  165.             this.key = key;
  166.             this.timeout = timeout;
  167.             this.redisTemplate = redisTemplate;
  168.             plusTime = timeout / 3;
  169.             service = new ScheduledThreadPoolExecutor(1);
  170.         }
  172.         /**
  173.          * 定时续命
  174.          *
  175.          * @author YangYudi
  176.          * @date 2020/12/24 16:29
  177.          */
  178.         public void schedule() {
  179.             service.scheduleAtFixedRate(() -> {
  180.                         //先获取key的时间 再判断时间是否快结束了 快结束了就续命
  181.                         //这段代码用lua脚本做好一点
  182.                         Long expire = redisTemplate.getExpire(key);
  183.                         if (!ObjectUtils.isEmpty(expire) && expire > 0 && expire <= plusTime) {
  184.                             redisTemplate.expire(key, expire + plusTime, TimeUnit.SECONDS);
  185.                             log.info("{} 续命成功", key);
  186.                         }
  187.                     },
  188.                     1, timeout / 3, TimeUnit.SECONDS);
  189.         }
  191.         /**
  192.          * 停止续命
  193.          *
  194.          * @author YangYudi
  195.          * @date 2020/12/24 16:29
  196.          */
  197.         public void shutdown() {
  198.             service.shutdown();
  199.         }
  201.     }
  203. }

调用

测试是否支持异步续命，可以在释放锁之前让线程睡眠

  1.     public String buy() {
  2.         int buy = 0;
  3.         //传入要锁住的key和redisTemplate
  4.         RedisLock redisLock = new RedisLock("1", redisTemplate);
  5.         try {
  6.             //加锁
  7.             redisLock.tryLock();
  8.             buy = orderService.buy();
  9.             try {
  10.                 Thread.sleep(30000);
  11.                 } catch (InterruptedException e) {
  12.                     e.printStackTrace();
  13.                 }
  14.         } finally {
  15.             //解锁
  16.             redisLock.releaseLock();
  17.         }
  18.         return String.valueOf(buy);
  19.     }