发布 v2.3.2

疯狂的狮子li

2021-06-11 83718c61cdd544f0a0190efa775ba7aeb08fedb0

 ruoyi-common/src/main/java/com/ruoyi/common/core/redis/RedisLockManager.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,170 @@
package com.ruoyi.common.core.redis;

import cn.hutool.core.lang.Assert;
import cn.hutool.core.lang.Validator;
import cn.hutool.core.util.StrUtil;
import org.redisson.api.RCountDownLatch;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * redis é”ç®¡ç†ç±»
 *
 * @author shenxinquan
 */
@Component
public class RedisLockManager {

   @Autowired
   private RedissonClient redissonClient;

   /**
    * é€šç”¨é”
    */
   private final static Integer BASE_LOCK = 1;

   /**
    * å…¬å¹³é”
    */
   private final static Integer FAIR_LOCK = 2;

   /**
    * å­˜æ”¾å½“前线程获取锁的类型
    */
   private final ThreadLocal<Integer> threadLocal = new ThreadLocal<>();

   /**
    * èŽ·å–锁
    */
   private RLock getLock(String key, Integer lockType) {
      Assert.isTrue(StrUtil.isNotBlank(key), "key不能为空");
      threadLocal.set(lockType);
      RLock lock;
      if (BASE_LOCK.equals(lockType)) {
         lock = redissonClient.getLock(key);
      } else if (FAIR_LOCK.equals(lockType)) {
         lock = redissonClient.getFairLock(key);
      } else {
         throw new RuntimeException("锁不存在!");
      }
      return lock;
   }

   /**
    * èŽ·å–锁（不用设置超时时间，一直等待）
    */
   public boolean getLock(String key) {
      RLock lock = getLock(key, BASE_LOCK);
      return lock.tryLock();
   }

   /**
    * è®¾ç½®è¿‡æœŸæ—¶é—´
    *
    * @param key
    * @param time       è¿‡æœŸæ—¶é—´
    * @param expireUnit æ—¶é—´å•ä½
    */
   public boolean getLock(String key, long time, TimeUnit expireUnit) {
      Assert.isTrue(time > 0, "过期时间必须大于0");
      Assert.isTrue(Validator.isNotEmpty(expireUnit), "时间单位不能为空");
      RLock lock = getLock(key, BASE_LOCK);
      try {
         return lock.tryLock(time, expireUnit);
      } catch (InterruptedException e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * è®¾ç½®è¿‡æœŸæ—¶é—´
    *
    * @param key
    * @param waitTime   èŽ·å–锁等待时间
    * @param leaseTime  ä¿ç•™é”çš„时间
    * @param expireUnit æ—¶é—´å•ä½
    */
   public boolean getLock(String key, long waitTime, long leaseTime, TimeUnit expireUnit) {
      Assert.isTrue(waitTime > 0, "获取锁等待时间必须大于0");
      Assert.isTrue(leaseTime > 0, "保留锁的时间必须大于0");
      Assert.isTrue(Validator.isNotEmpty(expireUnit), "时间单位不能为空");
      RLock lock = getLock(key, BASE_LOCK);
      try {
         return lock.tryLock(waitTime, leaseTime, expireUnit);
      } catch (InterruptedException e) {
         e.printStackTrace();
         return false;
      }
   }


   /**
    * èŽ·å–计数器锁
    *
    * @param key
    * @param count countDownLatch çš„数量
    */
   public RCountDownLatch getCountDownLatch(String key, long count) {
      Assert.isTrue(count >= 0, "count数量必须大于等于0");
      RCountDownLatch rCountDownLatch = redissonClient.getCountDownLatch(key);
      rCountDownLatch.trySetCount(count);
      return rCountDownLatch;
   }

   /**
    * èŽ·å–公平锁
    *
    * @param key
    * @param waitTime   èŽ·å–锁等待时间
    * @param leaseTime  æŒæœ‰é”çš„时间
    * @param expireUnit æ—¶é—´å•ä½
    * @return
    * @throws InterruptedException
    */
   public boolean getFairLock(String key, long waitTime, long leaseTime, TimeUnit expireUnit) {
      Assert.isTrue(waitTime > 0, "获取锁等待时间必须大于0");
      Assert.isTrue(leaseTime > 0, "保留锁的时间必须大于0");
      Assert.isTrue(Validator.isNotEmpty(expireUnit), "时间单位不能为空");
      RLock lock = getLock(key, FAIR_LOCK);
      try {
         return lock.tryLock(waitTime, leaseTime, expireUnit);
      } catch (InterruptedException e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * èŽ·å–公平锁
    *
    * @param key
    * @param leaseTime  æŒæœ‰é”çš„时间
    * @param expireUnit æ—¶é—´å•ä½
    */
   public boolean getFairLock(String key, long leaseTime, TimeUnit expireUnit) {
      Assert.isTrue(leaseTime > 0, "保留锁的时间必须大于0");
      Assert.isTrue(Validator.isNotEmpty(expireUnit), "时间单位不能为空");
      RLock lock = getLock(key, FAIR_LOCK);
      try {
         return lock.tryLock(leaseTime, expireUnit);
      } catch (InterruptedException e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * é‡Šæ”¾é”(统一释放)
    */
   public void unLock(String key) {
      Integer lockType = threadLocal.get();
      RLock lock = getLock(key, lockType);
      lock.unlock();
      threadLocal.remove();
   }
}