Redis分布式锁

毕业后一直做.Net工作，我喜欢C#更优美简洁的语法（虽然有些关键字或者类的命名有点隐晦）。当然Java也不能丢掉，Java的很多开源技术更能让我拓展视野，在分布式方面也更容易上手。空余时间正在将自己的一个个人项目用java重写，设计为一个分布式的项目，其中有减库存的操作。要做到全局同步，分布式锁正好用于解决此问题，在分布式环境下，多线程共享临界资源的场景下，分布式锁是一种非常重要的组件。Redis的单线程，setnx命令也是得天独厚。

我定义了一个接口，希望在将来做Redisson RedLock算法实现和ZK的分布式锁实现。下面lock是阻塞锁，实现应包含重试机制，trylock是非阻塞锁。

public interface DistributedLocker {

    boolean lock(String key) throws InterruptedException;

    boolean lock(String key,int expireSecond,int waitSecond) throws InterruptedException;

    boolean tryLock(String key);

    boolean tryLock(String key,int expireSecond);

    boolean releaseLock(String key);
}

public class RedisLocker implements DistributedLocker {

    private static ThreadLocal<String> threadLocal = new ThreadLocal<>();
    private JedisClient jedisClient;

    public void setClient(JedisClient client) {
        this.jedisClient = client;
    }

    private final int defaultExpireSeconds = 5;

    private final int defaultWaitSeconds = 100;

    @Override
    public boolean lock(String key) throws InterruptedException {

        return lock(key, defaultExpireSeconds, defaultWaitSeconds);
    }

    @Override
    public boolean lock(String key, int expireSecond, int waitSecond) throws InterruptedException {
        int maxDelayMillis = waitSecond * 1000;
        boolean isLockSucceed=false;
        while (maxDelayMillis>0){
            int delayTime = (int) (Math.random() * 20);
            maxDelayMillis-=delayTime;
            Thread.sleep(delayTime);
            System.out.println("wait "+delayTime);
            long startTime = System.currentTimeMillis();
            isLockSucceed= tryLock(key,expireSecond);
            long endTime = System.currentTimeMillis();
            System.out.println("network"+(endTime-startTime));
            maxDelayMillis=maxDelayMillis-delayTime-(int)(endTime-startTime);
            System.out.println("剩余"+maxDelayMillis);
            if (isLockSucceed){
                System.out.println("lock ok 剩余"+maxDelayMillis);
                break;
            }
        }

        return isLockSucceed;
    }

    @Override
    public boolean tryLock(String key) {
        return tryLock(key, defaultExpireSeconds);
    }

    @Override
    public boolean tryLock(String key, int expireSeconds) {

        String lockToken = threadLocal.get();
        if (StringUtils.isBlank(lockToken)) {
            System.out.println("token为空" + lockToken);
            lockToken = UUID.randomUUID().toString();
            threadLocal.set(lockToken);
        }

        boolean isLockSucceed = jedisClient.setNX(key, lockToken);
        if (isLockSucceed) {    //如果加锁成功
            jedisClient.expire(key, expireSeconds);
        } else {//如果加锁失败  判断是否应该重入
            String tokenFromRedis = jedisClient.get(key);
            System.out.println("tokenFromRedis：" + tokenFromRedis);
            if (lockToken.equals(tokenFromRedis)) {
                isLockSucceed = true;//可重入
                System.out.println("重入成功");
            }
        }
        System.out.println("获取锁结果" + isLockSucceed + " token为" + lockToken);
        return isLockSucceed;
    }

    @Override
    public boolean releaseLock(String key) {
        return jedisClient.del(key);
    }
}

可靠性分析：

1. key是一定要设置过期时间的，setnx原生命令不包含expire选项，需要使用key的命令。非原子操作遇到expire命令不成功也许是个灾难。原生的命令好像支持直接带expire 在jedis中不确定是不是版本问题 需要再确认。

2. 释放锁，也就是del key的时候，命令可能会执行失败，导致其他线程长期拿不到锁。

3. 锁丢失，为了解决单点问题，可能引入主从加哨兵（master&&slave&&sentinel），或者集群（redis cluster）。拿主从来说，如果master setnx命令执行成功，在数据未同步给slave的瞬间， master挂掉，从升主。这时 一个setnx的key，可能会被两个线程set成功，也就是两个线程都拿到了锁。

4. 临界时间，如果一个线程使用锁后，准备del 锁，这时key过期了，其他线程立即创建key 持有锁，现在del命令到达redis并删除了刚创建的key，就很惨了。