简洁易懂：源码+实战讲解Redisson并发锁及看门狗自动续期

最新推荐文章于 2024-03-18 17:48:01 发布
最新推荐文章于 2024-03-18 17:48:01 发布
阅读量3.7k 收藏 10
点赞数 2
分类专栏： # Spring # Redis 文章标签： lua java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xin_101/article/details/128950698
版权
Spring 同时被 2 个专栏收录
100 篇文章 6 订阅
订阅专栏
Redis
25 篇文章 7 订阅
订阅专栏

1 缘起

有一次同事问Redisson存储的键是否为hash？
我当时，没有看Redisson的相关源码，只知道应用，
所以没有办法回答，于是开始看看Redisson实现的源码，
顺便写了一个单机Redisson测试，
发现Redisson有看门狗功能，但是，不是所有的方法都会触发，
只有lock()方法才会触发看门狗，其他的方法不会触发看门狗功能，
如lock(long, TimeUnit)，tryLock()，
本文从结果触发，先理论分析，然后，代码实践验证。
先从源码讲解Redisson相关的知识，包括如何新建锁、释放锁、看门狗功能，
然后代码实战，验证这些功能，
感兴趣的同学可以手动调试。
帮助读者轻松应对知识交流与考核。

版本信息：
SpringBoot：2.1.7
Redisson：3.7.5

2 Redisson属性源码分析与验证

2.1 新建锁

位置：org.redisson.RedissonLock#tryLockInnerAsync
新建锁和可重入源码如下图所示，由源码可知，
Redisson使用Lua脚本新建锁。

  • 为什么？
    保证操作原子性。
    因为新建数据和添加过期时间是两步操作，不能保证原子性，
    因此使用Lua实现，保证新建锁时是原子操作。

Redisson实现的锁是可重入的。同一个线程获取锁，无需重新排队申请，只需增加锁的持有次数。

  • 怎么做？
    判断锁是的属性是否存在。
    通过hexists判断锁的属性是否存在（UUID:threadId），如果存在，值+1，同时，更新锁过期时间，
    使用Lua脚本，保证原子性。

在这里插入图片描述

Lua脚本中的参数KEYS[1]，ARGV[1], ARGV[2]，

  • 分别对应哪些参数呢？
    KEYS[1]：Collections.singletonList(getName())，即锁的键名；
    ARGV[1]：internalLockLeaseTime，即锁过期时间；
    ARGV[2]：getLockName(threadId)，即锁（Hash）属性的键，UUDI:threadId。
    其中，getLockName源码如下图所示，由图可知，UUID拼接threadId作为锁属性的键。
    顺便补充一下，Hash结构，键名，即获取该Hash的键，属性键名，即Hash内部数据的键。

在这里插入图片描述

下面看一下新建锁的调试过程，如下图所示，
（单步调试，如果操作不及时或者有其他时延，会导致Redis数据过期，因此，选择单步调试）
由图可知，新建的锁，键名称为redisLockKey，
默认锁过期时间为30秒，UUID为edb0f8cb-ec11-4b29-a107-12be152c4a5e，
threadId为71，锁属性的键为：edb0f8cb-ec11-4b29-a107-12be152c4a5e:71，属性键的值为1。
在这里插入图片描述
新建锁之后，会在Redis生成对应的数据，
如下图所示，由图可知，Redisson新建的锁键为redisLockKey，
锁属性名称为：edb0f8cb-ec11-4b29-a107-12be152c4a5e:71，属性值为1。
过期时间TTL已经开始倒计时了，实时的值为17秒。
在这里插入图片描述

2.2 获取锁

Redisson获取锁有两种方式：lock获取和tryLock获取。
lock()获取锁，如果得不到，会一直等，同时，lock()会开启看门狗功能，在看门狗巡查期间，锁不会过期；
lock(long, java.util.concurrent.TimeUnit)获取锁，会一直等，当锁过期后，即可自动获取；
tryLock()获取锁，得不到会一直等，当锁过期后，可自动获取到；
tryLock(long, long, java.util.concurrent.TimeUnit)获取锁，有两个时间参数，可以同时指定等待锁的最大时间，以及锁过期时间，如果等待最大时间大于锁过期时间，则锁被提前释放，重新生成锁；

2.2.1 lock

位置：java.util.concurrent.locks.Lock#lock

无参的lock方法来自JUC接口，
Redisson自身实现lock，并加入看门狗功能。
无返回值。
在这里插入图片描述
Redisson的实现源码如下图所示，这里给出路径，感兴趣可自行查看。
位置：org.redisson.RedissonLock#lock()

在这里插入图片描述

有参的lock源码如下图所示，
这个lock来自Redisson的RLock，添加了锁过期时间，
可以自定义锁的过期时间，这个获取锁的方法不会触发看门狗。
无返回值。

位置：org.redisson.api.RLock#lock
在这里插入图片描述
Redisson实现源码如下，这里给出路径，感兴趣可自行查看。
位置：org.redisson.RedissonLock#lock(long, java.util.concurrent.TimeUnit)
在这里插入图片描述

2.2.2 tryLock

位置：java.util.concurrent.locks.Lock#tryLock()
获取锁，无法获取时等待，当锁自动过期后，可自动获取。
有返回值，可通过返回值判断是否获得锁。
true：成功获取锁；
false：未获取锁。
在这里插入图片描述
Redisson实现tryLock源码如下图所示。
位置：org.redisson.RedissonLock#tryLock()
在这里插入图片描述

有参数的tryLock源码下图所示，有源码可知，
可指定最大等待锁时间、锁过期时间，
如果等待锁的最大时间小于锁过期时间，返回false，标识未得到锁。
如果等待锁的最大时间大于锁过期时间，等锁释放后，可自动获取锁，返回true，标识得到锁。
有返回值，可通过返回值判断是否获得锁。
true：成功获取锁；
false：未获取锁。
位置：org.redisson.api.RLock#tryLock

在这里插入图片描述

获取锁的实现源码如下图所示，这里给出路径，感兴趣可自行查看。
位置：org.redisson.RedissonLock#tryLock(long, long, java.util.concurrent.TimeUnit)
在这里插入图片描述

2.3 释放锁

位置：org.redisson.RedissonLock#unlockInnerAsync
释放锁源码如下图所示，由图可知，释放锁时会将锁属性的值-1，（加-1），
当释放的锁存在时，会将锁属性的值减1，减后的值大于零，重置锁的过期时间，保证锁的过期时间周期，
如果减1之后，锁属性值为0，即没有线程再持有锁，则删除该锁（del）。
在这里插入图片描述

2.4 锁续期

看门狗
位置：org.redisson.config.Config#lockWatchdogTimeout
看门狗的默认超时时间为30秒，即锁过期时间的续期为30秒，
看门狗的巡查周期为10秒，即每10秒更新一次锁的过期时间，设置为30秒。
两个是独立的时间系统。
30秒：锁的过期时间；
10秒：看门狗巡查周期。
这个10秒是如何得到的：30/3=10。

在这里插入图片描述

位置：org.redisson.RedissonLock#scheduleExpirationRenewal
看门狗进行锁续期的源码如下图所示，由源码可知，
当锁存在时，会延迟10秒执行更新锁过期时间，过期时间为30秒，
看门狗的巡查周期就是这个延迟时间：10秒。
在这里插入图片描述
当然，好奇的同学会问，锁的默认过期时间怎么就是30秒，
这个30秒是从哪里来的呢？
过期时间（internalLockLeaseTime）默认值取自看门狗的超时时间：30秒，上文有看门狗的默认值源码。
在这里插入图片描述

3 实战

版本信息：
SpringBoot：2.1.7
Redisson：3.7.5

3.1 依赖

<!--Redisson-->
<dependency>
	<groupId>org.redisson</groupId>
	<artifactId>redisson</artifactId>
	<version>3.7.5</version>
</dependency>

3.2 配置

3.2.1 Redis配置

application-dev.yml

spring:
  profiles: dev
  redis:
    host: localhost
    port: 6379
    # 连接超时时间：毫秒
    timeout: 60000
    database: 0
    lettuce:
      pool:
        # 连接池最大连接数量
        max-active: 8
        # 连接池最大阻塞等待时间：-1无限制
        max-wait: 60000
        # 连接池最大空闲连接数量
        max-idle: 8
        # 连接池最小空闲连接数量
        min-idle: 0

3.2.2 绑定Redis配置

package com.hardsoft.monkeyrun.common.lock;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

/**
 * Redis连接参数.
 *
 * @author xindaqi
 * @since 2021/4/2 11:41
 */
@Configuration
@ConfigurationProperties(prefix="spring.redis")
public class RedisConnectionParams {

    /**
     * 主机名
     */
    private String host;

    /**
     * 主机端口
     */
    private String port;

    /**
     * Redis连接超时时间：毫秒
     */
    private int timeout;

    /**
     * Redis数据库编号
     */
    private int database;

    public void setHost(String host) {
        this.host = host;
    }

    public String getHost() {
        return host;
    }

    public void setPort(String port) {
        this.port = port;
    }

    public String getPort() {
        return port;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    public int getTimeout() {
        return timeout;
    }

    public void setDatabase(int database) {
        this.database = database;
    }

    public int getDatabase() {
        return database;
    }

    @Override
    public String toString() {
        return "RedisConnectionParams{" +
                "host='" + host + '\'' +
                ", port='" + port + '\'' +
                ", timeout=" + timeout +
                ", database=" + database +
                '}';
    }
}

3.2.3 Redisson配置

package com.hardsoft.monkeyrun.common.config;

import com.hardsoft.monkeyrun.common.lock.RedisConnectionParams;
import com.hardsoft.monkeyrun.common.lock.RedissonLocker;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.SingleServerConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;

import static com.hardsoft.monkeyrun.common.constrant.StringConstant.COLON;
import static com.hardsoft.monkeyrun.common.constrant.StringConstant.REDISSON_SCHEMA;

/**
 * Redisson配置.
 *
 * @author xindaqi
 * @since 2021/4/2 11:34
 */
@Configuration
public class RedissonConfig {

    @Resource
    RedisConnectionParams redisConnectionParams;

    /**
     * 单机模式RedissonClient
     *
     * @return
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient() {
        Config config = new Config();
        SingleServerConfig singleServerConfig = config.useSingleServer();
        StringBuilder redisAddress = new StringBuilder();
        redisAddress.append(REDISSON_SCHEMA).append(redisConnectionParams.getHost()).append(COLON).append(redisConnectionParams.getPort());
        singleServerConfig.setAddress(redisAddress.toString());
        return Redisson.create(config);
    }

    @Bean
    public RedissonLocker redissonLocker(RedissonClient redissonClient) {
        return new RedissonLocker(redissonClient);
    }

}

3.2.4 Redisson获取锁封装

package com.hardsoft.monkeyrun.common.lock;

import com.hardsoft.monkeyrun.common.constrant.BooleanConstant;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

/**
 * Redisson锁
 *
 * @author xindaqi
 * @since 2021/3/30 19:01
 */
@Component
public class RedissonLocker {

    RedissonClient redissonClient;

    public RedissonLocker(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    /**
     * 获取锁
     * 如果锁不可用，则当前线程处于休眠状态，直到获得锁为止
     *
     * @param lockKey 锁键
     */
    public void lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
    }

    /**
     * 获取锁
     * 如果锁不可用，则当前线程处于休眠状态，直到获得锁为止，
     * 如果获取到锁后，执行结束后解锁或达到超时时间后自动释放锁
     *
     * @param lockKey 锁键
     * @param timeout 超时时间
     */
    public void lock(String lockKey, int timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, TimeUnit.SECONDS);
    }

    /**
     * 获得锁
     * 如果锁不可用，则当前线程处于休眠状态，直到获得锁后，
     * 执行结束后解锁或达到超时时间后会自动释放锁
     *
     * @param lockKey 锁键
     * @param unit 时间单位
     * @param timeout 超时时间
     */
    public void lock(String lockKey, TimeUnit unit, int timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
    }

    /**
     * 释放锁
     *
     * @param lockKey 锁键
     */
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }

    /**
     * 尝试获取锁
     * 获取到立即返回True
     * 未获取到返回False
     *
     * @param lockKey 锁键
     * @return 获取锁标志位，True：成功获取锁，False：未获取锁
     */
    public boolean tryLock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.tryLock();
    }

    /**
     * 尝试获取锁
     * 在等待时间内获取到锁则返回True，否则返回False
     * 获取到锁，两种执行逻辑：
     * 1.执行之后，释放锁
     * 2.达到释放时间leaseTime后，释放锁
     *
     * @param lockKey 锁键
     * @param waitTime 等待时间
     * @param leaseTime 释放时间
     * @param unit 时间单位
     * @return 获取锁标志位，True：成功获取锁，False：未获取锁
     * @throws InterruptedException
     */
    public boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.tryLock(waitTime, leaseTime, unit);
    }

    /**
     * 判断锁是否被任意一个线程持有
     *
     * @param lockKey 锁键
     * @return 锁持有标志位，True：锁被线程持有，False：锁没有被线程持有
     */
    public boolean isLocked(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.isLocked();
    }

    public void setRedissonClient(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }
}

3.3 接口测试

package com.hardsoft.monkeyrun.api.facade.lock;

import com.hardsoft.monkeyrun.common.constrant.BooleanConstant;
import com.hardsoft.monkeyrun.common.constrant.DigitalConstant;
import com.hardsoft.monkeyrun.common.enums.BizExceptionCodeEnums;
import com.hardsoft.monkeyrun.common.exception.BizException;
import com.hardsoft.monkeyrun.common.lock.RedissonLocker;
import com.hardsoft.monkeyrun.common.response.Response;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.TimeUnit;

import static com.hardsoft.monkeyrun.common.constrant.StringConstant.REDIS_LOCK_KEY;

/**
 * 锁测试
 *
 * @author xindaqi
 * @since 2021-04-03 11:28:18
 */
@RestController
@RequestMapping("/v1/lock")
public class LockTest {

    private static final Logger logger = LoggerFactory.getLogger(LockTest.class);

    private final String STOCK_WITH_REDISSON = "stock_with_redisson";

    private final String STOCK_WITHOUT_REDISSON = "stock_without_redisson";

    @Resource
    RedissonLocker redissonLocker;

    /**
     * 测试Redisson锁tryLock，不会激活看门狗，锁过期后，直接被清除
     * 
     * @return 响应
     */
    @GetMapping("/redisson/try-lock/test")
    public Response<String> testRedissonTryLock() {
        try {
            boolean lock1 = redissonLocker.tryLock(REDIS_LOCK_KEY, 100, 10, TimeUnit.SECONDS);
            if (lock1) {
                logger.info(">>>>>>>>得到锁");
                Thread.sleep(70000);
                return Response.success();
            } else {
                logger.info(">>>>>>>>未得到锁");
                return Response.fail();
            }
        } catch(Exception ex) {
            logger.error(">>>>>>>>Redisson异常：", ex);
            throw new BizException(BizExceptionCodeEnums.FAIL);
        } finally {
            logger.info(">>>>>>>释放Redisson锁");
            redissonLocker.unlock(REDIS_LOCK_KEY);
        }
    }

    /**
     * 测试Redisson看门狗功能：使用lock()获取锁，激活看门狗功能，每10秒自动续期30秒过期时间。
     * 
     * @return 响应
     */
    @GetMapping("/redisson/lock/test")
    public Response<String> testRedissonLock() {
        try {
            redissonLocker.lock(REDIS_LOCK_KEY);
            Thread.sleep(70000);
            return Response.success();
        } catch(Exception ex) {
            logger.error(">>>>>>>>Redisson异常：", ex);
            throw new BizException(BizExceptionCodeEnums.FAIL);
        } finally {
            logger.info(">>>>>>>释放Redisson锁");
            redissonLocker.unlock(REDIS_LOCK_KEY);
        }
    }
}

Redis结果：

在这里插入图片描述

4 结论

（1）Redisson锁存储使用Hash，Hash键为锁的键名，属性的键为UUID拼接ThreadId，格式：UUID:ThreadID，如xxx-xxx:30，属性的值为同一个线程获取锁的次数，Redisson的锁是可重入的，同一个线程获取锁，锁的数量+1，释放锁，数量减1；
（2）Redisson获取锁有两种方式，lock获取和tryLock获取，其中：
（2.1）lock获取锁时，如果第一次尝试获取获取失败，会一直等待，直到获取锁。Redisson的lock获取锁时，会为锁配置过期时间，当锁超过过期时间后，会自动释放，避免死锁，可以重新获得锁；
（2.2）lock()原始方法获取（不自定义超时（过期）时间）会激活看门狗。即通过lock()方法成功获取锁后，逻辑执行的时间超过看门狗超时时间：10秒，会自动为锁续期（增加）10秒的过期时间，使锁的过期时间保持在30秒（默认的锁过期时间）；
（2.3）lock(long, TimeUnit)带参方法可以指定锁过期时间，但是，不会触发看门狗自动续期；锁过期后，自动释放锁；
（2.4）tryLock方法返回标识位，获取成功，返回true，获取失败，返回false；tryLock尝试获取锁，无法获取锁时会等待，同时，tryLock有最大的等待时间，如果获取锁的等待时间超过最大等待时间，会放弃获取锁，并返回false；tryLock不会触发看门狗，无法自动为锁续期；
（2.5）tryLock可以同时指定等待锁的最大时间，以及锁过期时间，如果等待最大时间大于锁过期时间，则锁被提前释放，重新生成锁；
（3）Redisson看门狗默认巡查周期为10秒，锁续期时间（过期时间）30秒；
（4）Redisson看门口生效的方法为：lock()，其他方法均不会触发看门狗。

天然玩家
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
SpringCloud微服务架构实战教程(附源码+答疑)
06-19
SpringCloud是目前流行的微服务框架，在各大互联网公司都有广泛的应用，同时在企业招聘面试时也会要求对微服务技术栈有所了解和掌握。SpringCloud是一套完整的微服务解决方案，基于SpringBoot框架。 本课程以通俗易懂的方式讲解SpringCloud技术栈，由浅入深，帮您快速入门！详细讲解了SpringCloud的五大核心组件，同时准备了SpringCloud的案例项目，全面提升微服务的编程功底！ 教学全程采用笔记+代码案例的形式讲解，每个知识点都有详细的讲解，通俗易懂！！！ 部分讲义截图：
redisson的分布式锁对于后续业务超时的处理办法
会飞的小蜗
08-27 2455
在项目中，我们一般会使用redis的setnx与expire的原子操作来完成分布式锁的设置，但是会有一个问题是这样的，我们在上游设置了一个锁，比如是mylock，并给它设置了超时时间为12s ,但是下游业务由于要进行接口请求，执行了大概20s , 这样的话就会造成业务没有执行完的情况下锁就被释放掉了，那我们该如何解决此类问题呢？ Redisson 我们可以根据redisson的可重入锁，来设置分布式锁，使用的方式和java中的ReentrantLock基本一致。并且redisson内部提供了一个监控锁的看
Redis分布式锁如何自动续期
一江溪水
11-27 4916
Redis 实现分布式锁 指定一个 key 作为锁标记，存入 Redis 中，指定一个 唯一的用户标识作为 value。 当 key 不存在时才能设置值，确保同一时间只有一个客户端进程获得锁，满足互斥性特性。 设置一个过期时间，防止因系统异常导致没能删除这个 key，满足防死锁特性。 当处理完业务之后需要清除这个 key 来释放锁，清除 key 时需要校验 value 值，需要满足只有加锁的人才能释放锁 。 问题 如果这个锁的过期时间是30秒，但是业务运行超过了30秒，比如40秒，当业务运行到30秒的时
Redisson分布式锁（WatchDog分析，浅浅看下源码）
zhangximing的博客
03-18 1679
带大家简单了解下Redisson的看门狗机制，这个面试中也比较常见。
Docker入门与进阶实战(基于Java,通俗易懂,附源码)
06-19
Docker近几年非常火，因为它是容器虚拟化，更能够充分提高硬件资源的使用率。其实利用率高不算什么，它最大的优势是能给让运维人员或者开发人员快速部署和交付资源，大大提高了工作效率。 本课程以通俗易懂的方式讲解Docker容器技术，最适合初学者的教程，让你少走弯路！ 在学习过程中，遇到任何相关的问题可以及时联系沟通，第一时间使用远程协助工具帮助解决！ 教学全程采用笔记+代码案例的形式讲解，通俗易懂！！！
【OpenCV实战】简洁易懂的车牌号识别Python+OpenCV实现“超详解”（含代码）
12-21
前面4篇博客介绍了OpenCV图像处理的基础知识，本篇博客利用前4篇的知识完成一个小项目——车牌号码识别。该篇博客的代码可以满足小区门禁车牌号的识别。本篇博客是前4篇博客知识的一个综合运用。感觉学会了这个可以实现一系列的图像识别任务。。。毕竟好多技巧都是共通的 首先要感谢 大佬的博客 ，在它的基础上完成了自己的识别任务。 简洁易懂的车牌号识别Python实现“超详解”（含代码）1、整体思路2、代码详解2.1提取车牌位置2.2车牌字符的分割2.3模板匹配识别字符3、总结4、参考 1、整体思路 首先附上本次识别的图片：（图片是我在百度上找的） 基于OpenCV车牌号识别总体分为四个步骤： （1）
看门狗程序源码
12-18
专业源码都经过"网站编辑+检测员"双重人工检测,以确保所有上 线源码都不会携带病毒、恶意代码、插件等
Redisson 分布式锁的watch dog自动续期机制
xiaoshitou_2015的博客
04-05 1919
redis分布式锁无法自动续期，比如，一个锁设置了1分钟超时释放，如果拿到这个锁的线程在一分钟内没有执行完毕，那么这个锁就会被其他线程拿到，可能会导致严重的线上问题，我已经在秒杀系统故障排查文章中，看到好多因为这个缺陷导致的超卖了。Redisson提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期，也就是说，如果一个拿到锁的线程一直没有完成业务逻辑，那么看门狗会帮助线程不断的延长锁超时时间，锁不会因为超时而被释放。超过这个时间后锁便自动解开了，不会延长锁的有效期。
Redis系列之简单实现watchDog自动续期机制
Nicky's blog
12-12 1306
在分布锁的实际使用中，可能会遇到一种情况，一个业务执行时间很长，已经超过redis加锁的时间，也就是锁已经释放了，但是业务还没执行完成，这时候其它线程还是可以获取锁，那就没保证线程安全。具体的实现，主要是基于一个定时任务，时间间隔一定要比加锁时间少一点，这里暂时少1s，加上一个lua脚本进行检测，检测不到数据，就关了定时任务
Redisson中的看门狗
Y9CLONG的专栏
09-13 3797
我们在网上看到的redis分布式锁的工具方法，大都满足互斥、防止死锁的特性，有些工具方法会满足可重入特性。如果只满足上述3种特性会有哪些隐患呢？redis分布式锁无法自动续期，比如，一个锁设置了1分钟超时释放，如果拿到这个锁的线程在一分钟内没有执行完毕，那么这个锁就会被其他线程拿到，可能会导致严重的线上问题。然存在锁过期而任务未执行完毕的情况，那是否有一种可以在任务未完成时自动续期的机制呢，几年前在redisson中找到了看门狗的自动续期机制，就是解决这种分布式锁自动续期的问题的。
redisson中的看门狗机制
潇洒不放纵的博客
03-28 3412
redis分布式锁演示代码: public String hello() throws InterruptedException{ //获取一把锁,名称相同,就是同一把锁 RLock lock = redisson.getLock("my-lock"); //lock.lock(); lock.lock(10, TimeUnit.SECONDS);//自动解锁时间,一定要大于业务的执行时间 //问题lock.lock(10, T
通俗易懂的随机森林模型讲解
02-20
大家好，我是你们的好朋友小木。对于随机森林的模型，网上已经有灰常灰常多的讲解，大家讲的也非常的不错。但绝大多数大神讲解都是注重于理论，把算数的地方都给忽略了，我这次要以举例子的方法来讲解，这样可以让大家更好的理解随机森林模型。首先我们来定义一下随机森林，啥叫随机森林呢，森林指的是有一堆大树的地方，随机指每棵大树种植的过程中施肥的种类是随机地选择的。但是好好地一个模型怎么就变成大树了呢？当然不是啦，这里大树指的是决策树，而施肥指的是不同的限定条件。接下来，又有小朋友问我啥叫决策树，好大的一棵树啊，不懂o(∩_∩)o，那么我就来讲一下啥叫决策树。顾名思义，决策就是评价的意思，我们用一颗大树评价一个
基于C# 设计仓库管理系统源码+毕业论文WORD文档资料.zip
06-29
基于C# 设计仓库管理系统源码+毕业论文WORD文档资料: 摘要 在传统仓库管理过程中，表单填写与查询管理都非常的耗费人力物力，最后需要盘点或统计十分耗费时间和人力。同时由于采用手工操作，不可避免造成一些的错误。现在许多公司都采用计算机来管理仓库信息，避免了手工操作的不足。采用仓库管理信息对物资的出入情况进行管理，可以很方便地完成各类统计，为生产销售人员及时提供相关信息。 本系统主要实现仓库管理的自动化，包括货物的入库、出库、调库等操作，及货物有关信息的管理，如仓库单位管理、货物类别管理、供货商信息管理、客户档案管理和仓库管事操作员信息管理等。 本系统采用sql 2005作为后台的数据管理系统，以visual studio 2005作为前端开发工具,对数据进行添加、修改、保存、删除等处理，具有很强的实用性。 本系统主要功能是以管理员身份登录能够完成对库存等诸多信息进行实时管理功能。系统以提供操作简单、方便、易懂易用为开发目标，用户界面友好，及具有高效的数据处理能力。 关键词:仓库管理 信息管理系统 自动化
程序看门狗源码
07-06
看门狗，采用C#编写，使用了process 就是监控程序，发生异常的时候可以有及时响应
看门狗：军团（游戏源码）
12-03
Egregor组织放出的看门狗:军团的源码（种子），一共的560G大小。欢迎各位大佬下载试水
看门狗代码
02-02
基于linux的看门狗 应用源代码。 简单实用，下载下来直接编译运行即可
python实现的加密货币市场数据分析及可视化项目源码+使用文档说明.zip
最新发布
04-21
python实现的加密货币市场数据分析及可视化项目源码+使用文档说明.zip此次分析目的，就是使用python为加密货币的市场情况进行一次通俗易懂的分析。仅仅用很简单的python代码，完成对市场主流的加密货币数据的数据...
Redission
fwk19840301的博客
12-22 251
lock（）常用，有自动续期机制，所以不会出现锁到期多个线程进入业务代码的情况。需要手动解锁，否则会死锁，效率上比trylok高。但是没有trylok灵活 lock(long var1, TimeUnit var3)不常用， 到期自动解锁，会出现锁到期多个线程进入业务代码的情况，但是不会死锁，因为到期自动解锁 trylok(long var1,long var2,TimeUnit t)常用，灵活度高，可以设置获取不到锁做相应的代码处理或异常处理，需要手动解锁 String lockKey = "l..
Redisson的锁续期
京北游戏官方
01-29 8595
1.redisson的所有指令都通过lua脚本来完成，保证了原子性 2.redisson设置一个key的默认过期时间为30s，如果某个客户端持有一个锁超过了30s怎么办？redisson中有一个watchdog的概念，翻译过来就是看门狗，它会在你获取锁之后，每隔10s帮你把key的超时时间设置为30s，这样的话，就算一直持有锁也不会出现key过期了其他线程获取到锁的问题了。 3.redisson的看门狗逻辑保证了没有死锁的发生，但是如果宕机了，看门狗也没了，此时就不会延长key的过期时间，到了时间就会自动过
springboot vue 项目实战+课件 +源码 最新
06-23
### 回答1： Spring Boot和Vue是目前非常流行的前后端框架，在进行Web开发时都有很多优势。Spring Boot具有轻量级、易于开发、自动配置等特性，而Vue则可以实现前端组件化、响应式页面等功能。因此，很多开发者会选择使用这两个框架进行开发。 针对这一需求，市面上也出现了不少针对Spring Boot和Vue的项目实战课程。这些课程主要通过编写实际项目，让学员掌握如何使用这两个框架进行开发。同时，这些课程也会提供详细的课件和源码，方便学员进行学习和实践。 最新的Spring Boot和Vue项目实战课程会结合当前前后端技术的最新发展，融入了更多的实战案例和最佳实践。比如，集成了Spring Security进行安全控制、使用Axios处理HTTP请求、使用WebSocket实现实时通信等。 课程中的项目通常也是涵盖了多种功能和组件的完整应用，例如电商平台、博客系统等。学员通过编写这些项目，可以掌握到更多的实践技巧和思路，提高自己的开发能力和项目经验。 总之，Spring Boot和Vue项目实战课程是帮助开发者快速入门和掌握这两个框架的最佳途径之一。随着技术的发展和实际需求的不断变化，相信这类课程也会不断更新和升级，为开发者提供更多有价值的学习资源。 ### 回答2： SpringBoot Vue 项目实战课件是一门针对初学者和熟练的 Java/Web 开发者的课程，帮助他们了解如何使用 SpringBoot 和 Vue.js 构建 Web 应用程序。该课程配备了最新的源代码，学习者可以通过这些源代码深入了解课程内容，并进行相关的实践操作。 该课程内容包括了关于 Java 编程基础知识、Web 开发知识和 SpringBoot、Vue.js 框架使用方法的讲解。学习者将通过这些知识点构建一个全栈 Web 应用，从后端数据库的建立和管理到前端用户界面和交互的设计。 课程中涉及的核心内容包括了数据持久化、RESTful API 设计、SpringBoot + Vue.js 的集成开发、前后端数据传输和交互等一系列相关技术，以及针对生产环境的一些最佳实践。 该课程的源代码提供了清晰易懂的注释和详细的说明文档，让学习者可以更好地理解代码实现和编写方法，并通过对代码进行修改和优化的实践提升自身开发能力。总的来说，该课程和源代码的学习将帮助学习者掌握企业级应用的开发技术，并且具备便于移植和维护的代码实现能力。 ### 回答3： Springboot和Vue是现在非常流行的开发框架，结合起来可以开发出高效、稳定的Web应用程序。很多开发者由于缺少实战经验，难以掌握这两个框架的使用技巧。现在出现了一份最新的Springboot Vue项目实战课件和源码，可以帮助开发者快速掌握这两个框架的使用。 该课件包含了基础知识的讲解，从搭建环境、配置开发环境、运用Vue.js进行数据绑定、组建化开发等方面，详细的介绍了springboot和vue的使用方法。除此之外，课程还通过一个完整的项目实例来让开发者学习到如何将这两个框架结合起来进行开发。 该课程的源码也是非常完整的，完整体现出了各个功能模块之间的协作。在这个开源的项目中，你可以看到vue-router、Vue.js、Axios、ElementUI等多个框架的使用，每个文件都有详细的注释说明。这些源码可以让开发者实现对整个项目的深度理解，快速成为高级工程师。 总之，这份Springboot Vue项目实战课件和源码是一份很好的学习资料。通过这份资料，你可以快速入门，并且完成一个完整的项目，学习到如何使用这两个框架进行开发，提高自己的实战经验，为下一步的开发提供有效的基础。是很好的学习资料，建议开发者们去尝试学习。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天然玩家

坚持才能做到极致

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值