redis入门第九课：实战之分布式锁

当资源在分布式环境下需要共享时，比如秒杀等场景，减库存等。redis的客户端redission提供了一种基于LUA脚本的分布式锁实现方案来解决分布式环境下资源共享问题。

1.redission使用

public class RedissonUtil {
    
    public RedissonClient getConnetion(){
        Config config = new Config();
        //  单台服务器
        config.useSingleServer().setAddress("172.0.0.1:6379");
        return Redisson.create(config);
    }
    
    /**
     * 获取锁
     * @param key
     * @return
     */
    public boolean lock(String key){
        RLock lock = getConnetion().getLock("payOrder");
        //
        try {
            //最多等待100s，上锁10s后自动释放锁
            if (lock.tryLock(100, 10, TimeUnit.SECONDS)) {
                //获取锁成功
                System.out.println("获取锁成功了！");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }

2. 原理分析

来看看redission是如何实现的：
tryLock(long waitTime, long leaseTime, TimeUnit unit)源码如下：

@Override
    public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
        long time = unit.toMillis(waitTime);
        long current = System.currentTimeMillis();
        final long threadId = Thread.currentThread().getId();
        //申请锁，返回剩余过期时间
        Long ttl = tryAcquire(leaseTime, unit);
        // 无竞争...
        if (ttl == null) {
            return true;
        }
        
        //有竞争...
    }

2.1 先申请锁，然后返回锁剩余时间

• 将异步执行的结果以同步的形式返回
  Redisson 实现的执行 Redis 命令都是异步的，但是它在异步的基础上提供了以同步的方式获得执行结果的封装。

 private Long tryAcquire(long leaseTime, TimeUnit unit) {
        return get(tryAcquireAsync(leaseTime, unit, Thread.currentThread().getId()));
    }

• 异步获取锁
  分布式锁要确保未来的一段时间内锁一定能够被释放，因此要对锁设置超时释放的时间，在我们没有指定该时间的情况下，Redisson 默认指定为30秒

private  RFuture tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId) {
//1.如果用户设置的有最大等待时间，则直接执行LUA脚本获取锁
        if (leaseTime != -1) {
            return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
        }
 // 2.如果用户没有设置最大等待时间，用默认的锁超时时间去获取锁
        RFuture ttlRemainingFuture = tryLockInnerAsync(LOCK_EXPIRATION_INTERVAL_SECONDS, TimeUnit.SECONDS, threadId, RedisCommands.EVAL_LONG);
        ttlRemainingFuture.addListener(new FutureListener() {
            @Override
            public void operationComplete(Future future) throws Exception {
                if (!future.isSuccess()) {
                    return;
                }

                Long ttlRemaining = future.getNow();
                // lock acquired
                if (ttlRemaining == null) {
 // 3.锁过期时间刷新任务调度
                    scheduleExpirationRenewal(threadId);
                }
            }
        });
        return ttlRemainingFuture;
    }

• 使用 EVAL 命令执行 Lua 脚本获取锁

  RFuture tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand command) {
        internalLockLeaseTime = unit.toMillis(leaseTime);

        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
                  "if (redis.call('exists', KEYS[1]) == 0) then " +
                      "redis.call('hset', KEYS[1], ARGV[2], 1); " +
                      "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                      "return nil; " +
                  "end; " +
                  "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                      "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                      "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                      "return nil; " +
                  "end; " +
                  "return redis.call('pttl', KEYS[1]);",
                    Collections.