Redis(三十四)-Redisson分布式锁看门狗

Posted 码农飞哥

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Redis(三十四)-Redisson分布式锁看门狗相关的知识,希望对你有一定的参考价值。

您好,我是码农飞哥,感谢您阅读本文,欢迎一键三连哦
💪🏻 1. Python基础专栏,基础知识一网打尽,9.9元买不了吃亏,买不了上当。 Python从入门到精通
❤️ 2. Python爬虫专栏,系统性的学习爬虫的知识点。9.9元买不了吃亏,买不了上当 。python爬虫入门进阶
❤️ 3. Ceph实战,从原理到实战应有尽有。 Ceph实战
❤️ 4. Java高并发编程入门,打卡学习Java高并发。 Java高并发编程入门
😁 5. 社区逛一逛,周周有福利,周周有惊喜。码农飞哥社区,飞跃计划
全网同名【码农飞哥】欢迎关注,个人VX: wei158556

文章目录

1. 简介

上一篇文章我们介绍了用如何用Redis做分布式锁Redis(三十二)-用Redis做分布式锁
在文章的末尾留下了个问题:

  1. 业务还没执行完,Redis分布式锁就过期了该怎么办?,由于我们给锁指定了过期时间,极有可能会出现业务还还没执行完,分布式锁就过期的情况。针对这种情况,我们该如何处理呢?

可能我们最先想到的方案就是:给分布式锁设置更长的有效时间,但是这只是治标不治本的一种方式。你无法保证业务流程在你设置的过期时间内就一定能执行完成。

针对这种情况,最好的方式就是在分布式锁快要过期,但是,自动延长分布式锁的过期时间。如果要我们来实现这个过程可能有点复杂。
还在已经有大佬帮我们实现了。我们只需要直接拿来用就好了。

现在就隆重请出 Redisson:它独有的看门狗(Watchdog)功能就可以帮我们轻易的实现。

2. Redisson怎么用

2.1. 引入依赖

   <!--jedis客户端-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.6.0</version>
        </dependency>
        <!--jedis客户端-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.16.0</version>
        </dependency>

2.2. 写个简单的demo测试

public class LockDemo 
    private final RedissonClient redissonClient;

    public LockDemo(RedissonClient redissonClient) 
        this.redissonClient = redissonClient;
    

    public static void main(String[] args) throws InterruptedException 
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        LockDemo lockDemo = new LockDemo(Redisson.create(config));
        lockDemo.reentrantLock();

        new Thread(lockDemo::reentrantLock_expire, "线程一").start();
        TimeUnit.SECONDS.sleep(30);
        new Thread(lockDemo::reentrantLock_expire, "线程二").start();
        TimeUnit.SECONDS.sleep(30);
    


    /**
     * 加锁,默认的时长是30秒,不指定超时时间
     */
    public void reentrantLock() 
        RLock lock = redissonClient.getLock("reentrant-lock-no-expire");
        //没有获取到锁,返回
        lock.lock();
        long startTime = System.currentTimeMillis();
        try 
            // 模拟业务操作耗时
            System.out.println("模拟业务开始");
            TimeUnit.SECONDS.sleep(60);
            System.out.println("模拟业务结束,共耗时=" + (System.currentTimeMillis() - startTime) / 1000);
         catch (InterruptedException e) 
            e.printStackTrace();
         finally 
            System.out.println("手动释放锁,共耗时=" + (System.currentTimeMillis() - startTime) / 1000);
            lock.unlock();
        
    

    /**
     * 加锁,指定锁的时长是25秒
     */
    public void reentrantLock_expire() 
        RLock lock = redissonClient.getLock("reentrant-lock-expire");
        long startTime = System.currentTimeMillis();
        lock.lock(25, TimeUnit.SECONDS);
        System.out.println(Thread.currentThread().getName() + "获取到锁");
        try 
            // 模拟业务操作耗时
            System.out.println(Thread.currentThread().getName() + "模拟业务开始");
            TimeUnit.SECONDS.sleep(60);
            System.out.println(Thread.currentThread().getName() + "模拟业务结束,共耗时=" + (System.currentTimeMillis() - startTime) / 1000);
         catch (InterruptedException e) 
            e.printStackTrace();
         finally 
            System.out.println(Thread.currentThread().getName() + "手动释放锁,共耗时=" + (System.currentTimeMillis() - startTime) / 1000);
            lock.unlock();
        
    

    public void release() 
        this.redissonClient.shutdown();
    

运行结果:

从上述运行结果可以看出,如下几个结论。

  1. Redisson的lock()方法不指定过期时间的话,默认的过期时间是30秒,当过期时间超过1/3时,看门狗会自动续期(比如过期时间是30秒,则在10s的时候,看门狗就会自动续期),续期后的锁的时长重新变成30s
  2. Redisson的lock(long leaseTime, TimeUnit unit)方法指定过期时间时,当到达过期时间时锁会自动释放,也就是说在这种情况下,看门狗失效。
  3. Redisson的锁与线程相关,每个线程只能释放自己的锁,不能释放别的线程的锁。

3.源码分析

3.1. 获取锁

  //不指定过期时间
  @Override
    public void lock() 
        try 
            lock(-1, null, false);
         catch (InterruptedException e) 
            throw new IllegalStateException();
        
    
    //指定过期时间
    @Override
    public void lock(long leaseTime, TimeUnit unit) 
        try 
            lock(leaseTime, unit, false);
         catch (InterruptedException e) 
            throw new IllegalStateException();
        
    

这两个访问最终调用的都是lock(long leaseTime, TimeUnit unit, boolean interruptibly) 方法,唯一的区别是lock()方法传入的是参数leaseTime值是-1,而lock(long leaseTime, TimeUnit unit)传入的参数值是leaseTime。
让我们接着看看lock(long leaseTime, TimeUnit unit, boolean interruptibly)方法。

 private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException 
        long threadId = Thread.currentThread().getId();
        //获取锁,获取锁时带入线程ID
        Long ttl = tryAcquire(-1, leaseTime, unit, threadId);
        // lock acquired (获取到锁直接返回)
        if (ttl == null) 
            return;
        
        
        //订阅锁,这样锁释放时会被通知到
        RFuture<RedissonLockEntry> future = subscribe(threadId);
        if (interruptibly) 
            commandExecutor.syncSubscriptionInterrupted(future);
         else 
            commandExecutor.syncSubscription(future);
        
        
         //没获取到锁,死循环等待
        .....

这个方法主要tryAcquire(-1, leaseTime, unit, threadId) 方法来获取锁,获取时传入了当前线程ID。而tryAcquire方法内部主逻辑优势调用tryAcquireAsync方法。下面就直接查看tryAcquireAsync方法。

 private <T> RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) 
        RFuture<Long> ttlRemainingFuture;
        if (leaseTime != -1) 
            //指定过期时间
            ttlRemainingFuture = tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
         else 
            //不指定过期时间时,过期时间设为看门狗超时时间internalLockLeaseTime,然后由看门狗一直续期,直到锁释放
            ttlRemainingFuture = tryLockInnerAsync(waitTime, internalLockLeaseTime,
                    TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
        
        //
        ttlRemainingFuture.onComplete((ttlRemaining, e) -> 
            if (e != null) 
                return;
            

            // lock acquired(获取到锁)
            if (ttlRemaining == null) 
                if (leaseTime != -1) 
                    //指定过期时间的话,则不续期
                    internalLockLeaseTime = unit.toMillis(leaseTime);
                 else 
                     // 未指定过期时间,需要开启Watchdog自动续期
                    scheduleExpirationRenewal(threadId);
                
            
        );
        return ttlRemainingFuture;
    

从这里面我们可以看出两个重要的信息,第一个信息是指定过期时间的话不续期,未指定过期时间的话,则会开启Watchdog自动续期。internalLockLeaseTime的默认时间是30秒。private long lockWatchdogTimeout = 30 * 1000;
首先看下尝试获取锁的实现,tryLockInnerAsync方法通过EVAL执行LUA脚本,代码如下:

 return evalWriteAsync(getRawName(), LongCodec.INSTANCE, command,
                "if (redis.call('exists', KEYS[1]) == 0) then " +
                        "redis.call('hincrby', 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.singletonList(getRawName()), unit.toMillis(leaseTime), getLockName(threadId));

它的主要逻辑是:

  1. 若锁不存在,则设置锁,并设置过期时间,然后返回nil。
  2. 若锁存在且由本线程持有,则锁计数加一,并重设过期时间,然后返回nil;
  3. 否则返回锁的过期时间;
    然后,看下看门狗是如何给锁续期的呢?直接查看scheduleExpirationRenewal方法。
    protected void scheduleExpirationRenewal(long threadId) 
        ExpirationEntry entry = new ExpirationEntry();
        ExpirationEntry oldEntry = EXPIRATION_RENEWAL_MAP.putIfAbsent(getEntryName(), entry);
        if (oldEntry != null) 
           //重入加锁
            oldEntry.addThreadId(threadId);
         else 
           //第一次加锁,触发定时任务。
            entry.addThreadId(threadId);
            renewExpiration();
        
    

接着看看renewExpiration这个方法,

 private void renewExpiration() 
        ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName());
        if (ee == null) 
            return;
        
     // 借助Netty的Timeout实现自动续期
    // 超时时间为1/3过期时间,确保在过期前能够重设过期时间
        Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() 
            @Override
            public void run(Timeout timeout) throws Exception 
                ExpirationEntry ent = EXPIRATION_RENEWAL_MAP.get(getEntryName());
                if (ent == null) 
                    return;
                
                Long threadId = ent.getFirstThreadId();
                if (threadId == null) 
                    return;
                
                
                RFuture<Boolean> future = renewExpirationAsync(threadId);
                future.onComplete((res, e) -> 
                    if (e != null) 
                        log.error("Can't update lock " + getRawName() + " expiration", e);
                        EXPIRATION_RENEWAL_MAP.remove(getEntryName());
                        return;
                    
                    
                    if (res) 
                        // reschedule itself 
                        renewExpiration();
                    
                );
            
            //过期时间超过1/3的话则会需求
        , internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);
        
        ee.setTimeout(task);
    

续期的方法是renewExpirationAsync方法。这个方法也是一个LUA脚本,这个脚本的主要逻辑是,如果锁存在的话,则将过期时间重新设置为30s。

    protected RFuture<Boolean> renewExpirationAsync(long threadId) 
        return evalWriteAsync(getRawName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                        "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                        "return 1; " +
                        "end; " +
                        "return 0;",
                Collections.singletonList(getRawName()),
                internalLockLeaseTime, getLockName(threadId));
    

参考

Redisson的“看门狗”机制,一个关于分布式锁的非比寻常的BUG
Redis学习之Redisson分布式锁看门狗
Redisson的看门狗watchDog机制是怎么实现的?

以上是关于Redis(三十四)-Redisson分布式锁看门狗的主要内容,如果未能解决你的问题,请参考以下文章

redisson中的看门狗机制总结

SpringBoot整合Redisson

踩到一个关于分布式锁的非比寻常的BUG!

Redis实战——Redisson分布式锁

redis分布式锁redisson

redis并发读写锁,使用Redisson实现分布式锁