Redis 分布式锁 + Lua原子操作

package com.example.demo.redis;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.exceptions.JedisNoScriptException;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class RedisLockUtil {
    

    //分布式锁相关字段
    private static final String LOCK_SUCCESS = "OK";
    private static final String SET_IF_NOT_EXIST = "NX";
    private static final String SET_WITH_EXPIRE_TIME = "PX";
    private static final Long RELEASE_SUCCESS = 1L;
    private static final Long UNLOCK_SUCCESS_CODE = 1L;
    private volatile String unlockSha1 = "";

    private static final Logger logger = LoggerFactory.getLogger(RedisLockUtil.class);

    /** * 通过lua脚本释放锁,来达到释放锁的原子操作 * 判断锁住值是否为当前线程持有，是的话解锁，不是的话解锁失败 */
    String UNLOCK_LUA = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";

    @Autowired
    private JedisCluster jedisCluster;

    /** * 根据loopTryTime循环重试 * @param lockKey 锁key * @param lockVal 锁值，用于解锁校验 * @param expiryTime 锁过期时间 * @param loopTryTime 获取失败时，循环重试获取锁的时长 * @return 是否获得锁 */
    public boolean tryLock(String lockKey, String lockVal, long expiryTime, long loopTryTime){
    
        Long endTime = System.currentTimeMillis() + loopTryTime;
        while (System.currentTimeMillis() < endTime){
    
            if (tryGetDistributedLock(lockKey, lockVal, expiryTime)){
    
                return true;
            }
        }
        return false;
    }

    /** * 尝试获取分布式锁 * @param lockKey 锁 * @param requestId 请求标识 * @param expireTime 超期时间 * @return 是否获取成功 */
    public Boolean tryGetDistributedLock(String lockKey, String requestId, long expireTime) {
    
        String result = jedisCluster.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);
        if (LOCK_SUCCESS.equals(result)) {
    
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }

    /** * 释放分布式锁 * @param lockKey 锁 * @param requestId 请求标识 * @return 是否释放成功 */
    public Boolean tryUnLockEval(String lockKey, String requestId) {
    
        Object result = jedisCluster.eval(UNLOCK_LUA, Collections.singletonList(lockKey), Collections.singletonList(requestId));
        if (RELEASE_SUCCESS.equals(result)) {
    
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }

    /** * 释放分布式锁，释放失败最可能是业务执行时间长于lockKey过期时间，应当结合业务场景调整过期时间 * @param lockKey 锁key * @param lockVal 锁值 * @return 是否释放成功 */
    public boolean tryUnLockEvalsha(String lockKey, String lockVal){
    
        List<String> keys = new ArrayList<>();
        keys.add(lockKey);
        List<String> argv = new ArrayList<>();
        argv.add(lockVal);
        try {
    
            Object result = jedisCluster.evalsha(unlockSha1, keys, argv);
            return UNLOCK_SUCCESS_CODE.equals(result);
        } catch (JedisNoScriptException e){
    
            //没有脚本缓存时，重新发送缓存
            logger.info("try to store script......");
            storeScript(lockKey);
            Object result = jedisCluster.evalsha(unlockSha1, keys, argv);
            return UNLOCK_SUCCESS_CODE.equals(result);
        } catch (Exception e){
    
            logger.info(e.getMessage());
            return false;
        }
    }
    /** * 由于使用redis集群，因此每个节点都需要各自缓存一份脚本数据 * @param slotKey 用来定位对应的slot的slotKey */
    public void storeScript(String slotKey){
    
        if (StringUtils.isEmpty(unlockSha1) || !jedisCluster.scriptExists(unlockSha1, slotKey)){
    
            //redis支持脚本缓存，返回哈希码，后续可以继续用来调用脚本
            unlockSha1 = jedisCluster.scriptLoad(UNLOCK_LUA, slotKey);
        }
    }

}