关于分布式等待锁

@woshiqiuxiaoyan

基于Redis setnx

话不多说直接上源码：

  /**
     * 锁
     * @author: QXY
     * @createTime: 2019/2/22
     * @version: 1.0
     * @param key  需要锁住的key
     * @param xid tcc的xid
     * @param frequency 重试的频率
     * @param timeoutInSecond 获取锁的超时时间（单位：毫秒）
     * @param redisKeyExpireSeconds 持有锁的最长时间（单位：毫秒）
     * @param lockCallback  状态对应处理事件
     * @return T
     */
    public <T> T lockTCC(String key,String xid,LockRetryFrequency frequency,int timeoutInSecond,int redisKeyExpireSeconds,MyLockCallback<T> lockCallback) {
        long curentTime = System.currentTimeMillis();

        /*
         * 设置加锁过期时间
         */
        long expireSecond = curentTime / 1000L + redisKeyExpireSeconds;
        /*
         * 作为值存入锁中(记录这把锁持有最终时限)
         */
        long expireMillisSecond = curentTime + redisKeyExpireSeconds * 1000L;
        /*
         * 获取锁的超时时间的最后时刻
         */
        long timeoutExprieTime = curentTime + (long)(timeoutInSecond * 1000) - (long)frequency.getRetrySpan();
        /*
         * 重试测试
         */
        int retryCount = timeoutInSecond * 1000 / frequency.getRetrySpan();

        String tccKey=xid+key;

        String value= String.valueOf(expireMillisSecond)+","+tccKey;

        for (int i = 0; i < retryCount; ++i) {
            if (this.redisClient.setnx(key,XID_LOCK_NAMESPACE,value,DefaultDbIndex).longValue() == 1L) {
                /*
                 *  tcc 锁
                 */
                    log.debug("obtain the lock: {},  at {} retry",key,i);
                    T t;
                    try {
                        this.redisClient.expireAt(key,XID_LOCK_NAMESPACE,expireSecond,DefaultDbIndex);
                        return lockCallback.handleObtainLock();
                    } catch (Exception e) {
                        /*
                         * 解分布式锁
                         */
                        this.redisClient.del(key,XID_LOCK_NAMESPACE,DefaultDbIndex);
                        MyLockException ie = new MyLockException(e);
                        t = lockCallback.handleException(ie);
                    }
                    return t;
            }

            if (System.currentTimeMillis() >= timeoutExprieTime) {
                log.debug("=============超时没有获得锁，双重校验",key);
                break;
            }
            log.debug("============没有获得锁重试",key,i);
            try {
                Thread.sleep((long)frequency.getRetrySpan());
            } catch (InterruptedException e) {
                log.error("Interrupte exception",e);
            }
        }

        String expireSpecifiedInString = this.redisClient.get(key,XID_LOCK_NAMESPACE,null,DefaultDbIndex);
        if (StringUtils.isNotBlank(expireSpecifiedInString)) {
            long expireSpecified = Long.valueOf(expireSpecifiedInString.split(",")[0]).longValue();
            if (curentTime > expireSpecified) {
                log.warn("===============持有锁超时,删除锁:{} ,{},{}",new Object[] {key,expireSpecified,curentTime});
                this.redisClient.del(key,XID_LOCK_NAMESPACE,DefaultDbIndex);
            }
        }
        return  lockCallback.handleNotObtainLock();
    }



    /**
     * 解tcc锁
     * @author: QXY
     * @createTime: 2019/2/22
     * @version: 1.0
     * @param key
     * @param xid
     * @return void
     */
    @Override
    public void unLockTCC(String key,String xid){
        String tccKey=xid+key;
        String value =   this.redisClient.get(key,XID_LOCK_NAMESPACE,null,DefaultDbIndex);
        if(StringUtils.isNotBlank(value)
                && tccKey.equals(value.split(",")[1])){
            this.redisClient.del(key,XID_LOCK_NAMESPACE,DefaultDbIndex);
        }
    }
/**
 * @Author qxy
 * @class LockRetryFrequency
 * @Date: 2019/2/22 14:41
 * @Descript: 重试间隔时间（单位毫秒）
 */
@Getter
public enum LockRetryFrequency {
    VERY_QUICK(10),
    QUICK(50),
    NORMAL(100),
    SLOW(500),
    VERY_SLOW(1000);

    private int retrySpan = 100;

    LockRetryFrequency(int rf) {
        this.retrySpan = rf;
    }
}


/**
 * 处理锁的各种状态
 * @Author qxy
 * @class LockCallback
 * @Date: 2019/2/22 15:29
 * @Descript: 处理锁的各种状态
 */
public interface MyLockCallback<T> {
    /**
     * 获取锁处理方式
     * @author: QXY
     * @createTime: 2019/2/22
     * @version: 1.0
     * @param
     * @return T
     */
    T handleObtainLock();

    /**
     * 没有获得锁处理方式
     * @author: QXY
     * @createTime: 2019/2/22
     * @version: 1.0
     * @param
     * @return T
     */
    T handleNotObtainLock();

    /**
     * 用户处理时发生异常处理回调
     * @author: QXY
     * @createTime: 2019/2/22
     * @version: 1.0
     * @param var1
     * @return T
     */
    T handleException(MyLockException var1) throws MyLockException;
}

基本使用（在confirm 和cancel 中必须解锁）：

@源码git

参考 《redis in action》

参考链接: link