redission分布式锁释放异常问题

前言：

    线上使用reidsson做分布式锁的实现，经常看到线上会报当前线程未持有锁，不能释放锁异常，慌的一批。异常信息如下：

java.lang.IllegalMonitorStateException: attempt to unlock lock, not locked by current thread by node id: aa9c450d-2b24-4588-a03e-d7f9f4bb7c9a thread-id: 6238
    at org.redisson.RedissonLock.operationComplete(RedissonLock.java:564)
    at io.netty.util.concurrent.DefaultPromise.notifyListener0(DefaultPromise.java:577)
    at io.netty.util.concurrent.DefaultPromise.notifyListeners0(DefaultPromise.java:570)
    at io.netty.util.concurrent.DefaultPromise.notifyListenersNow(DefaultPromise.java:549)
    at io.netty.util.concurrent.DefaultPromise.notifyListeners(DefaultPromise.java:490)
    at io.netty.util.concurrent.DefaultPromise.setValue0(DefaultPromise.java:615)

加锁demo

boolean lock = false;
            try {
              //获取锁，在10秒内持续获取锁
               lock = redissonClient.getLock("lockName").tryLock(10,TimeUnit.SECONDS);
               if(lock){//模拟业务操作一分钟
                   TimeUnit.MINUTES.sleep(1);
               }
            } catch (InterruptedException e) {
                log.error("系统异常",e);
                Thread.currentThread().interrupt();
            } finally {
                    //释放锁，这里直接释放锁，一般情况下也不会有问题。
                    redissonClient.getLock("lockName").unlock();
            }

一开始看加锁和解锁的代码也没什么异常啊，为啥在线上偶尔会出现上述异常信息？，百思不得其姐。
只能去撸redis源码了...错了，只能先百度看看有没有其他大佬已经碰到并解决这个问题了
持续百度中...
发现还是有大佬碰到相同问题类似的问题的：具体可以参考资料:https://www.jianshu.com/p/b12e1c0b3917
上面blog说的是lock()方法获取锁线程中断导致redis释放锁时抛了IllegalMonitorStateException异常，
然后也给出了对应的复现demo代码
但是，我用的是tryLock()方法，撸了三遍加锁的代码也没找到加锁失败的情况下会调用Thread.currentThread().interrupt();来中断线程。
然后得出结论，呸，然后怀疑最终导致释放锁异常的原因可能是在并发争锁的情况下：
线程1获取到锁，还未释放时，线程2开始获取锁，获取失败，直接走到finally去释放锁，这时后锁的持有者还是线程1，线程2去释放锁会报异常。
写个demo试试？

@Test
    public void testLock(){
        Thread thread_1 = new LockWithoutBoolean("thread-1",redissonClient);
        Thread thread_2 = new LockWithoutBoolean("thread-2",redissonClient);
        thread_1.start();
        try {
            TimeUnit.SECONDS.sleep(2); // 睡2秒钟 为了让thread_1获取到锁
            thread_2.start();
            TimeUnit.SECONDS.sleep(2000); // 让主线程在两子线程之后结束
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

    }
    static class LockWithoutBoolean extends Thread {
        private String name;
        private RedissonClient redissonClient;
        public LockWithoutBoolean(String name, RedissonClient redissonClient) {
            super(name);
            this.redissonClient=redissonClient;
        }
        public void run() {
           boolean lock = false;
            try {
               lock = redissonClient.getLock("lockName").tryLock(10,TimeUnit.SECONDS);
               if(lock){
                   TimeUnit.MINUTES.sleep(1);
               }
            } catch (InterruptedException e) {
                log.error("系统异常",e);
                Thread.currentThread().interrupt();
            } finally {
                    redissonClient.getLock("lockName").unlock();
            }
        }
    }

结果重现了线上释放锁异常

Exception in thread "thread-2" java.lang.IllegalMonitorStateException: attempt to unlock lock, not locked by current thread by node id: 9e874b6a-7880-44c7-8bdf-ef5abad43484 thread-id: 738
    at org.redisson.RedissonLock.operationComplete(RedissonLock.java:564)
    at io.netty.util.concurrent.DefaultPromise.notifyListener0(DefaultPromise.java:577)
    at io.netty.util.concurrent.DefaultPromise.notifyListenersNow(DefaultPromise.java:551)
    at io.netty.util.concurrent.DefaultPromise.notifyListeners(DefaultPromise.java:490)
    at io.netty.util.concurrent.DefaultPromise.addListener(DefaultPromise.java:183)
    at org.redisson.misc.RedissonPromise.addListener(RedissonPromise.java:124)
    at org.redisson.misc.RedissonPromise.addListener(RedissonPromise.java:42)
    at org.redisson.RedissonLock.unlockAsync(RedissonLock.java:553)
    at org.redisson.RedissonLock.unlock(RedissonLock.java:443)
    at lock.LockTest$LockWithoutBoolean.run(LockTest.java:59)

注意：上述异常，只有在线程1获取到锁，线程2等待获取锁超时的情况下去释放锁才会必现。线上一般获取锁会设置超时时间为5s，也就是说线程1只要在5s内能释放锁也就不会产生上述问题了，所以线上用锁量那么大，也是少部分释放锁会产生异常。
那么，问题来了，释放锁为啥会报这个异常？
我们来看看释放锁的关键源码

protected RFuture<Boolean> unlockInnerAsync(long threadId) {
        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                "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; " +
                        "local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
                        "if (counter > 0) then " +
                        "redis.call('pexpire', KEYS[1], ARGV[2]); " +
                        "return 0; " +
                        "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));

    }

这里是说：
1、如果key不存在，则表示锁不存在，返回成功
2、如果key存在，本线程id获取锁不存在，则表示当前线程不是锁的持有者，释放锁抛异常(上述异常)
3、否则，获取当前线程的锁的使用次数，因为同一个锁在同一个线程是可重入的,每次获取锁，计数+1
所以需要判断锁的使用次数，如果counter>0,则锁持有次数-1，否则直接删除锁，返回成功
4、其他情况都返回异常
最后排查完终于放心了，该异常不会导致死锁，锁续约等问题，因为线程1最终还是会正确的释放锁的，不用担心线上故障
虽然问题不大，但是线上老出这种异常信息看着太难受了，顺便给出解决方案吧
知道问题根源，解决起来就简单了
在上面释放锁的地方加上以下判断即可。只有获取锁成功才去释放锁。

 if(lock){
                    redissonClient.getLock("lockName").unlock();
            }

当然你要觉得low了，你也可以用redisson自带的isLocked(),和isHeldByCurrentThread()方法来判断，区别就是后者的判断需要多请求两次redis，前者只需要在业务代码中标记获取锁成功才去释放，所以，当然用前者啦

 if(lock.isLocked()&&lock.isHeldByCurrentThread()){
                            lock.unlock();
                            log.info("释放分布式锁成功key:{}", key);
                        }

另外：推荐我另外一篇blog，统一来管理分布式锁的加解锁：基于事务实现redis分布式锁自动释放的实现