SpringBoot使用Redisson实现分布式锁秒杀

本篇文章采用的是单机模式，具体可以参考官网redisson介绍。
 

Redisson源码分析

Redisson实现了Lock接口，对比Lock而言，是可重入锁，功能强大，源码复杂。

加锁

用代码举例子

public static void main(String[] args) {
    Config config = new Config();
    config.useSingleServer().setAddress("redis://118.190.55.83:6379");
    RedissonClient client = Redisson.create(config);
    RLock lock = client.getLock("lock1");
    try {
        // 加锁
        lock.lock();
    } finally {
        // 解锁
       lock.unlock();
    }
}

RLock lock = client.getLock("lock1");这句代码就是为了获取锁的实例。

查看 lock.lock(); 的源码

@Override
public void lock() {
    try {
        lockInterruptibly();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

查看 lockInterruptibly 方法

@Override
public void lockInterruptibly(long leaseTime, TimeUnit unit) throws InterruptedException {
    // 获取当前线程的id
    long threadId = Thread.currentThread().getId();
    // 尝试获取锁
    Long ttl = tryAcquire(leaseTime, unit, threadId);
    // lock acquired ，ttl为空，说明成功获取锁，返回
    if (ttl == null) {
        return;
    }

    // 如果获取锁失败，则订阅到对应这个锁的channel
    RFuture future = subscribe(threadId);
    commandExecutor.syncSubscription(future);

    try {
        // 
        while (true) {
        	// 再次尝试获取锁
            ttl = tryAcquire(leaseTime, unit, threadId);
            // lock acquired ， ttl为空，说明成功获取锁，返回
            if (ttl == null) {
                break;
            }

            // waiting for message ， ttl大于0 则等待ttl时间后继续尝试获取
            if (ttl >= 0) {
                getEntry(threadId).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
            } else {
                getEntry(threadId).getLatch().acquire();
            }
        }
    } finally {
        // 取消对channel的订阅
        unsubscribe(future, threadId);
    }
	// get(lockAsync(leaseTime, unit));
}

流程图：

查看 tryAcquireAsync 方法

private  RFuture tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId) {
    // 如果存在过期时间，按照正常费那事获取锁
    if (leaseTime != -1) {
        return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
    }
    // 读取配置的默认加锁时间30秒执行获取锁的  private long lockWatchdogTimeout = 30 * 1000; 
    RFuture ttlRemainingFuture = tryLockInnerAsync(commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, 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) {
                scheduleExpirationRenewal(threadId);
            }
        }
    });
    return ttlRemainingFuture;
}

继续看 tryLockInnerAsync 方法，采用LUA脚本代码加锁。

 RFuture tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand command) {
	// 设置过期时间
    internalLockLeaseTime = unit.toMillis(leaseTime);

    return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
    		  // 如果锁不存在，则通过hset设置它的值，并设置过期时间
              "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; " +
              // 如果锁已存在，并且锁的是当前线程，则通过hincrby给数值递增1
              "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; " +
              // //如果锁已存在，但并非本线程，则返回过期时间ttl
              "return redis.call('pttl', KEYS[1]);",
                Collections.