redis分布式可重入锁

redis分布式可重入锁
关于分布式锁和线程锁及可重入锁和不可重入锁的区别，不懂的同学可百度了解。

package com.thgy.bc.common.lock;

import com.thgy.bc.common.enums.ErrorInfoEnum;
import com.thgy.common.api.model.exception.BizException;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * RedisLock
 *
 * @author liangqiang
 * @version 1.0
 * @date 2021/06/24
 */
@Component
@Getter
@Slf4j
public class RedisLock {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 账户redis锁前缀
     */
    final String REDIS_ACCOUNT_LOCK_PRE = "ACCOUNT";

    /**
     * 佣金redis锁前缀
     */
    final String REDIS_COMISSION_PRE = "COMISSION";

    /**
     * 获取锁超时毫秒数
     */
    final long REDIS_LOCK_TIMEOUT = 10000;

    /**
     * 可重入锁的数量
     */
    private static ThreadLocal<Integer> localCount = new ThreadLocal<Integer>();

    /**
     * 上锁的key
     */
    private static ThreadLocal<String> localKey = new ThreadLocal<String>();

    /**
     * 该加锁方法仅针对单实例 Redis 可实现分布式加锁
     * 对于 Redis 集群则无法使用
     * 分布式可重入锁
     * 支持重复，线程安全
     *
     * @param lockKey   加锁键
     * @param value  加锁值
     * @param seconds   锁过期时间
     * @return
     */
    public <K,V> boolean lock(K lockKey, V value, long seconds) {
        //判断是否重入锁
        if(StringUtils.isBlank(localKey.get())){
            // 系统当前时间，毫秒
            long nowTime = System.currentTimeMillis();
            while ((System.currentTimeMillis() - nowTime) < REDIS_LOCK_TIMEOUT) {
                if (redisTemplate.opsForValue().setIfAbsent(lockKey, value, seconds, TimeUnit.SECONDS)) {
                    log.info("获取redis锁成功，key:"+ lockKey + ",value:" + value);
                    localKey.set(String.valueOf(lockKey));
                    localCount.set(0);
                    return true;
                }
                // 每次请求等待一段时间
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }else {
            localCount.set(localCount.get() + 1);
            log.info("获取redis重入锁成功，key:"+ lockKey + ",value:" + value + ",重入锁数量：" + localCount.get());
            return true;
        }
        log.error("获取redis锁等待超时，key:"+ lockKey + ",value:" + value);
        //响应超时
        throw new BizException(ErrorInfoEnum.RESPONSE_TIMEOUT);
    }


    /**
     * 与 tryLock 相对应，用作释放锁
     * 注意：当任务执行时间大于超时时间情况下，存在意外释放后续操作hold的锁的可能
     *
     * @param lockKey
     * @return
     */
    public <K> void releaseLock(K lockKey) {
        //数量大于0则是重入锁
        if(StringUtils.isNotBlank(localKey.get()) && localCount.get() != null && localCount.get() > 0){
            localCount.set(localCount.get() - 1);
        }else{
            localCount.remove();
            localCount.remove();
            redisTemplate.delete(lockKey);
        }
    }

    /**
     * 获取锁，释放锁，用于try（）{}自动close资源
     * @param lockKey
     * @param value
     * @param seconds
     * @param <K>
     * @param <V>
     * @return
     */
    public <K,V> AutoCloseable tryLock(K lockKey, V value, long seconds) {
        lock(lockKey, value, seconds);
        return () -> {
            releaseLock(lockKey);
        };
    }
}