update redis锁工具类编写

sxq

2021-06-08 f45b50a796e1db1238b1147f11c2f96c0d405e48

update redis锁工具类编写

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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,132 @@
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 ThreadLocal<RLock> threadLocal = new ThreadLocal<>();

    /**
     * èŽ·å–锁（不用设置超时时间，一直等待）
     */
    public boolean getLock(String key) {
        Assert.isTrue(StrUtil.isNotBlank(key), "key不能为空");
        RLock lock = redissonClient.getLock(key);
        threadLocal.set(lock);
        return lock.tryLock();
    }

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

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

    /**
     * èŽ·å–计数器锁
     *
     * @param key
     * @param count countDownLatch çš„数量
     */
    public RCountDownLatch countDownLatch(String key, long count) {
        Assert.isTrue(StrUtil.isNotBlank(key), "key不能为空");
        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) throws InterruptedException {
        Assert.isTrue(StrUtil.isNotBlank(key), "key不能为空");
        Assert.isTrue(waitTime > 0, "获取锁等待时间必须大于0");
        Assert.isTrue(leaseTime > 0, "保留锁的时间必须大于0");
        Assert.isTrue(Validator.isNotEmpty(expireUnit), "时间单位不能为空");
        RLock lock = redissonClient.getFairLock(key);
        threadLocal.set(lock);
        return lock.tryLock(waitTime, leaseTime, expireUnit);
    }

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

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