Redisson 源码初探（四）释放锁

Love The Way You Lie 2022-10-31 13:58 124阅读 0赞

@Override
        public void unlock() {
            try {
                //unlockAsync 是异步化的释放锁
                //这里的get 包裹是将异步变为同步
                get(unlockAsync(Thread.currentThread().getId()));
            } catch (RedisException e) {
                if (e.getCause() instanceof IllegalMonitorStateException) {
                    throw (IllegalMonitorStateException)e.getCause();
                } else {
                    throw e;
                }
            }

@Override
        public RFuture<Void> unlockAsync(final long threadId) {
            final RPromise<Void> result = new RedissonPromise<Void>();
            RFuture<Boolean> future = unlockInnerAsync(threadId);
    
            future.addListener(new FutureListener<Boolean>() {
                @Override
                public void operationComplete(Future<Boolean> future) throws Exception {
                    if (!future.isSuccess()) {
                        cancelExpirationRenewal(threadId);
                        result.tryFailure(future.cause());
                        return;
                    }
    
                    Boolean opStatus = future.getNow();
                    if (opStatus == null) {
                        IllegalMonitorStateException cause = new IllegalMonitorStateException("attempt to unlock lock, not locked by current thread by node id: "
                                + id + " thread-id: " + threadId);
                        result.tryFailure(cause);
                        return;
                    }
                    if (opStatus) {
                        cancelExpirationRenewal(null);
                    }
                    result.trySuccess(null);
                }
            });
    
            return result;
        }

同样是一段lua脚本

KEY\[1\] ：锁名称

KEY\[2\] : channelName

ARGV\[1\]  ： unlockMessage

ARGV\[2\] : internalLockLeaseTime

ARGV\[3\] :  线程唯一标识 (UUID + ":" + ThreadId)

Redis 是支持发布订阅模式的，可以针对某个channel key 进行订阅，别人发布订阅消息，就可以监听到，那么这里的作用是什么？肯定就是通知其他想加锁的线程尝试加锁对吧

protected RFuture<Boolean> unlockInnerAsync(long threadId) {
            
            return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                    //判断锁是否存在，不存在就往channel 中发送一个消息
                    "if (redis.call('exists', KEYS[1]) == 0) then " +
                        "redis.call('publish', KEYS[2], ARGV[1]); " +
                        "return 1; " +
                    "end;" +
                    //如果锁存在，但不是当前线程持有，那么什么都不做
                    "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +
                        "return nil;" +
                    "end; " +
                    //如果能到这，说明已经是当前线程持有锁
                    //将锁对应的标志位 -1 
                    "local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
                    //如果-1 后 value值 大于0，说明是重入了几次锁，再次设置过期时间
                    "if (counter > 0) then " +
                        "redis.call('pexpire', KEYS[1], ARGV[2]); " +
                        "return 0; " +
                    //否则将key删除，也就是释放锁，并往channel中投递一个消息，其实就是通知订阅者，让他们去尝试加锁
                    "else " +
                        "redis.call('del', KEYS[1]); " +
                        "redis.call('publish', KEYS[2], ARGV[1]); " +
                        "return 1; "+
                    "end; " +
                    "return nil;",
                    Arrays.<Object>asList(getName(), getChannelName()), LockPubSub.unlockMessage, internalLockLeaseTime, getLockName(threadId));
    
        }

其实redisson 释放锁的逻辑还是比较清晰的。