# Redis 分布式锁如何自动续期

Redis 分布式锁如何自动续期

何为分布式

  • 分布式，从狭义上理解，也与集群差不多，但是它的组织比较松散，不像集群，有一定组织性，一台服务器宕了，其他的服务器可以顶上来。分布式的每一个节点，都完成不同的业务，一个节点宕了，这个业务就不可访问了。
  • 分布式是指将一个业务拆分不同的子业务，分布在不同的机器上执行。

分布式锁

  • 为了保证操作共享资源在高并发情况下的同一时间只能被同一个线程执行，在单体应用单机部署的情况下，可以使用Java并发处理相关的API(如ReentrantLcok或synchronized)进行互斥控制，这是在JVM层面的加锁方式。
  • 单体单机部署的系统被演化成分布式系统后，由于分布式系统多线程、多进程并且分布在不同机器上，这将使原单机部署情况下的并发控制锁策略失效，为了解决这个问题就需要一种跨JVM的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题
    在这里插入图片描述
  • 分布式锁是一种用于在分布式系统中实现互斥访问的机制。它可以确保在多个节点同时访问共享资源时，只有一个节点能够获取到锁并执行操作，其他节点需要等待。

分布式锁的实现方式

基于数据库

  • 可以使用数据库的事务机制来实现分布式锁。通过在数据库中创建一个特定的表或记录来表示锁的状态，当节点需要获取锁时，尝试插入或更新这个表或记录，如果成功则获取到锁，否则等待。

基于缓存

  • 可以使用分布式缓存如Redis或Memcached来实现分布式锁。通过在缓存中设置一个特定的键值对来表示锁的状态，当节点需要获取锁时，尝试设置这个键值对，如果成功则获取到锁，否则等待。

基于ZooKeeper

  • ZooKeeper是一个分布式协调服务，可以用于实现分布式锁。通过创建临时顺序节点来表示锁的状态，当节点需要获取锁时，尝试创建自己的临时顺序节点，并检查是否是最小的节点，如果是则获取到锁，否则监听前一个节点的删除事件，等待。

基于分布式算法

  • 还有一些基于分布式算法的实现方式，如Chubby、Raft等。这些算法通过选举、协调等机制来实现分布式锁。

需要注意的是，分布式锁的实现需要考虑到并发性、可靠性和性能等方面的问题，选择合适的实现方式需要根据具体的需求和场景进行评估。

分布式锁的特点

  • 互斥性：在任意时刻，只有一个客户端能持有锁。
  • 不会发生死锁：即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。
  • 容错性：只要大部分的Redis节点正常运行，客户端就可以加锁和解锁。
  • 可重入性：加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。

Redis实现分布式锁

Redis Setnx命令

  • Redis Setnx（SET if Not eXists） 命令在指定的 key 不存在时，为 key 设置指定的值。
redis 127.0.0.1:6379> SETNX KEY_NAME VALUE
  • 设置成功，返回 1 。 设置失败，返回 0 。

Set命令

  • setnx不能同时完成expire设置失效时长，不能保证setnx和expire的原子性。我们可以使用set命令完成setnx和expire的操作，并且这种操作是原子操作。

  • 例子：设置lock=test，失效时长3s，不存在时设置 set lock test ex 3 nx。设置成功返回OK，设置失败返回null

SpringBoot使用Redis分布式锁

基于RedisTemplate

  • 假设业务代码块在 6s之内处理完成，那么下面的代码就不会有业务代码执行超时，分布式锁没有问题
  • 如果业务代码执行耗时较长，那么设置的键会自动过期，导致上个业务还没有执行结束，下个业务还能拿到锁，分布式锁失效
/**
  * Set 实现分布式锁子
  */
@Override
public void setRedisLock() {

    // redis Key
    String redisKey = "ID_1001";
    // value 身份标识
    String redisValue = UUID.randomUUID().toString();

    try {

        // 获取分布式锁，设置超时时间 6s 假设业务代码最长 6s 执行完毕
        ValueOperations valueOperations = redisTemplate.opsForValue();
        boolean lockFlag = !valueOperations
            .setIfAbsent(redisKey, redisValue, 6, TimeUnit.SECONDS).booleanValue();
        if (lockFlag) {
            throw new Exception("redis key：" + redisKey + " 值：" + redisValue + " 获取锁失败");
        } else {
            logger.info("redis key：{} 值：{} 获取锁成功", redisKey, redisValue);
        }

        // 实现业务代码：暂时假设业务代码执行时长在 6s 之内

    } catch (Exception e) {
        logger.error(e.getMessage(), e);
        throw new RuntimeException(e.getMessage());
    } finally {
        boolean deleteFlag;
        String currentValue = (String) redisTemplate.opsForValue().get(redisKey);
        if (redisValue.equals(currentValue)) {
            deleteFlag = redisTemplate.opsForValue().getOperations().delete(redisKey).booleanValue();
            if (deleteFlag) {
                logger.info("redis 锁：{} 释放成功", redisKey);
            } else {
                logger.error("redis 锁：{} 释放失败", redisKey);
            }
        } else {
            logger.error("redis 锁：{} 值：{} 身份校验失败无法释放", redisKey, redisValue);
        }
    }

}

Redis分布式锁续期处理

  • 在上面的例子中，当业务代码执行耗时超过redis设置的超时时间时，下一个任务获取锁的时候还是会获取成功，这样在业务上是又问题的。所以得要考虑处理锁续期。
  • 实现思路，开启一个定时任务作为守护线程，如果业务代码没有执行完成主动进行续期操作
  • 任务完整之后终止守护线程，释放获取的锁
@Override
public void setRedisLock1() {

    // redis Key
    String redisKey = "ID_1001";

    TestTask testTask = new TestTask();
    CustomResponse response = execute(testTask, redisKey, 7, true);
    if (response.getCode() != 0) {
        logger.error("线程：" + Thread.currentThread().getId() + "执行结果：" + response.getMsg());
    }
}


/**
  * 利用redis做分布式锁
  *
  * @param runnable   执行的业务
  * @param lockKey    锁定key， 不同业务应该全局唯一
  * @param lockTime   锁定时间 （单位 ms）
  * @param autoRelock 是否自动续期
  */
public CustomResponse execute(Runnable runnable, String lockKey, long lockTime, boolean autoRelock) {
    CustomResponse customResponse = new CustomResponse();
    execute(runnable, lockKey, lockTime, autoRelock, customResponse);
    return customResponse;
}

/**
  * 利用redis做分布式锁
  *
  * @param runnable       执行的业务
  * @param lockKey        锁定key， 不同业务应该全局唯一
  * @param lockTime       锁定时间 （单位 ms）
  * @param autoRelock     是否自动续期
  * @param customResponse 执行结果
  */
public void execute(Runnable runnable, String lockKey, long lockTime, boolean autoRelock, CustomResponse customResponse) {


    if (customResponse == null) {
        throw new IllegalArgumentException("customResponse 参数不能为空");
    }

    if (lockTime <= 0) {
        throw new IllegalArgumentException("请设置正确的 redis key 超时时间");
    }

    boolean flag = true;
    boolean completedFlag = true;
    TimerTask timerTask = null;

    ScheduledFuture<?> scheduledFuture = null;
    try {

        // 失效时间，设置失败的key强制删除
        Long hasKeyExpire = redisTemplate.getExpire(lockKey);
        if (hasKeyExpire != null && hasKeyExpire.intValue() == -1) {
            redisTemplate.delete(lockKey);
        }

        ValueOperations<String, String> operations = redisTemplate.opsForValue();
        if (Boolean.TRUE.equals(operations.setIfAbsent(lockKey, "1", lockTime, TimeUnit.MILLISECONDS))) {

            // 开启续期，超时时间之后开始任务
            if (autoRelock) {
                timerTask = new TimerTask() {
                    public void run() {
                        logger.info("redis key:{} 自动续期任务执行...", lockKey);
                        redisTemplate.opsForValue().setIfPresent(lockKey, "1", lockTime, TimeUnit.MILLISECONDS);
                    }
                };

                try {
                    scheduledFuture = scheduledExecutorService.scheduleAtFixedRate(timerTask, lockTime / 2, lockTime, TimeUnit.SECONDS);
                } catch (Throwable e) {
                    logger.debug(e.getMessage());
                }
            }

            customResponse.setMsg(0, "获取 redis 锁成功");

            // 执行业务逻辑
            try {
                runnable.run();
                // 处理标志位
                completedFlag = false;
            } catch (Throwable e) {
                logger.error("redis key：{} 执行业务代码出错：{}", lockKey, e.getMessage(), e);
                customResponse.setMsg(500, e.getMessage());
            }
        } else {
            flag = false;
            customResponse.setMsg(100, "获取锁失败");
        }
    } catch (Throwable e) {
        if (completedFlag) {
            logger.error(e.getMessage(), e);
            customResponse.setMsg(500, e.getMessage());
        }
    } finally {

        try {

            // 删除自己设置的锁
            if (flag) {
                redisTemplate.delete(lockKey);
                logger.info("执行完成删除自己的 key");
            }

            // 移除定时任务
            timerTask.cancel();
            if (Objects.nonNull(scheduledFuture)) {
                scheduledFuture.cancel(true);
            }

        } catch (Throwable e) {
            logger.debug(e.getMessage(), e);
        }
    }
}


private class TestTask implements Runnable {

    @Override
    public void run() {
        try {
            logger.info("任务开始执行...");
            Thread.sleep(10000);
            logger.info("任务执行结束...");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}
  • 获取锁：使用Redis的SETNX命令尝试获取锁。如果返回1表示获取锁成功，返回0表示锁已被其他进程持有。
  • 设置锁的过期时间：如果成功获取到锁，可以使用Redis的EXPIRE命令设置锁的过期时间，确保在一定时间后自动释放锁。
  • 续期处理：在业务处理过程中，可以定期（比如锁过期时间的一半）使用Redis的EXPIRE命令来延长锁的过期时间，防止锁过期后被其他进程获取。
  • 释放锁：在业务处理完成后，使用Redis的DEL命令释放锁。
  • 需要注意的是，分布式锁的续期处理需要保证原子性，避免多个进程同时续期导致锁被误释放。可以使用Redis的Lua脚本来保证续期操作的原子性。 另外，为了防止进程异常退出或崩溃导致锁无法释放，可以使用Redis的SET命令设置一个唯一的锁标识，并在获取锁和续期操作时进行比对，确保只有持有锁的进程才能释放锁。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/356970.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

leetcode刷题(剑指offer) 50.Pow(x, n)

leetcode刷题(剑指offer) 50.Pow(x, n)

50.Pow(x, n) 实现 pow(x, n) &#xff0c;即计算 x 的整数 n 次幂函数&#xff08;即&#xff0c;xn &#xff09;。 示例 1&#xff1a; 输入&#xff1a;x 2.00000, n 10 输出&#xff1a;1024.00000示例 2&#xff1a; 输入&#xff1a;x 2.10000, n 3 输出&#x…
阅读更多...
一天吃透Java集合面试八股文

一天吃透Java集合面试八股文

内容摘自我的学习网站&#xff1a;topjavaer.cn 常见的集合有哪些&#xff1f; Java集合类主要由两个接口Collection和Map派生出来的&#xff0c;Collection有三个子接口&#xff1a;List、Set、Queue。 Java集合框架图如下&#xff1a; List代表了有序可重复集合&#xff0c…
阅读更多...
密码加密——MD5与BCryptPasswordEncoder

密码加密——MD5与BCryptPasswordEncoder

目录 一、问题 二、密码加密 1、MD5密码加密 2、BCryptPasswordEncoder加密&#xff08;推荐&#xff09; 2.1 特点 2.2 使用步骤 一、问题 在数据库表中的密码都是明文存储的&#xff0c;安全性太低 需求&#xff1a; 将密码加密后存储&#xff0c;提高安全性 二、密码加密…
阅读更多...
【Axure教程0基础入门】04交互动效基础

【Axure教程0基础入门】04交互动效基础

04交互动效基础 1.Axure交互事件的基本概念 &#xff08;1&#xff09;交互动效Interaction 原型图中&#xff0c;原件与页面的动态效果&#xff08;dynamic behaviors&#xff09;。 &#xff08;2&#xff09;交互动效的构成 目标&#xff08;target&#xff09;&#xff1a;…
阅读更多...
Kotlin基础——高阶函数和内联函数

Kotlin基础——高阶函数和内联函数

高阶函数 高阶函数以另一个函数作为参数或者返回值&#xff0c;其可用Lambda或函数引用表示 函数类型 下面将Lambda存储在sum变量中&#xff0c;其是函数类型 val sum { x: Int, y: Int -> x y }完整的函数类型为(para1,prar2…) -> returnValue val a: Int 0 va…
阅读更多...
Vue学习之nodejs环境搭建中的坑

Vue学习之nodejs环境搭建中的坑

Vue学习之nodejs环境搭建中的坑 1.nodejs安装后环境变量配置 &#xff08;1&#xff09;在nodejs安装目录下已有node_cache、node_global&#xff0c;如下&#xff1a; &#xff08;2&#xff09;在系统属性->环境变量中新建一个名为NODE_PATH的系统变量&#xff0c;值为n…
阅读更多...
pytest框架的基本使用

pytest框架的基本使用

1. 测试框架的作用 测试框架不关系用例的内容 它关心的是&#xff1a;用例编排和结果收集 2. pytest框架的特点 1. 适用于python语言 2. 用法符合python风格 3. 有丰富的生态 3. 安装pytest框架 1. 新建一个项目 2. 在项目终端窗口输入如下命令&#xff0c;用于安装py…
阅读更多...
基于springboot网吧管理系统源码和论文

基于springboot网吧管理系统源码和论文

随着信息技术和网络技术的飞速发展&#xff0c;人类已进入全新信息化时代&#xff0c;传统管理技术已无法高效&#xff0c;便捷地管理信息。为了迎合时代需求&#xff0c;优化管理效率&#xff0c;各种各样的管理系统应运而生&#xff0c;各行各业相继进入信息管理时代&#xf…
阅读更多...
Zygote的启动流程

Zygote的启动流程

在zygote进程对应的文件是app_main.cpp文件&#xff0c;在app_main.cpp文件的main()方法中先解析了init.rc中配置的参数并根据配置的参数设置zygote的状态。 在状态设置阶段主要做了&#xff1a; 设置进程名称为zygote通过startSystemServer true标示启动的是systemServer调…
阅读更多...
6.s081 学习实验记录（三）system calls

6.s081 学习实验记录（三）system calls

文章目录 一、use gdb二、syscall&#xff1a;trace注意&#xff1a;实验代码&#xff1a;实验结果&#xff1a; 三、sysinfotips&#xff1a;实验代码实验结果 需要切换到 syscall 分支 一、use gdb 学习使用 gdb 调试 make qemu-gdb打开一个新的终端&#xff1a; gdb-mult…
阅读更多...
换个思路快速上手UML和plantUML——时序图

换个思路快速上手UML和plantUML——时序图

上一章我们介绍了类图&#xff0c;我们很清楚&#xff0c;类图是从更加宏观的角度去梳理系统结构的&#xff0c;从类图中我们可以获取到类与类之间&#xff1a;继承&#xff0c;实现等关系信息&#xff0c;是宏观逻辑。下面我们继续换一个思路&#xff1a;作为一名软件工程结构…
阅读更多...
【周赛】第382场周赛

【周赛】第382场周赛

&#x1f525;博客主页&#xff1a; A_SHOWY&#x1f3a5;系列专栏&#xff1a;力扣刷题总结录 数据结构 云计算 数字图像处理 力扣每日一题_ 从这一场&#xff08;第382场周赛&#xff09;周赛开始记录&#xff0c;目标是尽快达到准确快速AC前三道题&#xff0c;每场比赛…
阅读更多...
贝莱德里程碑

贝莱德里程碑

作者&#xff1a;秦晋 见证奇迹的时刻。 1月27日&#xff0c;全球资产管理巨头贝莱德在美国证监会于1月10日审批通过比特币ETF的17天内&#xff0c;其比特币现货ETF资产管理规模已经突破20亿美元。持有比特币总数已达49952个。领跑其他9只比特币ETF机构参与者。不包括灰度GBTC&…
阅读更多...
【JavaScript 漫游】专栏介绍

【JavaScript 漫游】专栏介绍

专栏介绍 本专栏旨在记录 JavaScript 核心语法&#xff0c;作为笔者日常学习和工作中的参考手册和代码示例仓库。 内容上力求覆盖 ES5、DOM、BOM 和 ES6 规范的所有内容。对于常用且重要的知识点&#xff0c;应该详细描述并附带有大量的代码示例。对于在工作场景中很少用到的…
阅读更多...
数据结构——用Java实现二分搜索树

数据结构——用Java实现二分搜索树

目录 一、树 二、二分搜索树 1.二叉树 2.二分搜索树 三、代码实现 1.树的构建 2.获取树中结点的个数 3.添加元素 4.查找元素 &#xff08;1&#xff09;查找元素是否存在 &#xff08;2&#xff09;查找最小元素 &#xff08;3&#xff09;查找最大元素 5.二分搜索…
阅读更多...
算法39：统计全 1 子矩形（力扣1504）----单调栈

算法39：统计全 1 子矩形（力扣1504）----单调栈

题目: 给你一个 m x n 的二进制矩阵 mat &#xff0c;请你返回有多少个 子矩形 的元素全部都是 1 。 示例 1&#xff1a; 输入&#xff1a;mat [[1,0,1],[1,1,0],[1,1,0]] 输出&#xff1a;13 解释&#xff1a; 有 6 个 1x1 的矩形。 有 2 个 1x2 的矩形。 有 3 个 2x1 的矩…
阅读更多...
（2024|ICLR，MAD，真实数据与合成数据，自吞噬循环）自消耗生成模型变得疯狂

（2024|ICLR，MAD，真实数据与合成数据，自吞噬循环）自消耗生成模型变得疯狂

Self-Consuming Generative Models Go MAD 公和众和号&#xff1a;EDPJ&#xff08;进 Q 交流群&#xff1a;922230617 或加 VX&#xff1a;CV_EDPJ 进 V 交流群&#xff09; 目录 0. 摘要 2. 自吞噬生成模型 2.1 自吞噬过程 2.2 自吞噬过程的变体 2.3 自吞噬循环中的偏…
阅读更多...
Advanced EFS Data Recovery：恢复 Windows NTFS 中 EFS 加密文件

Advanced EFS Data Recovery：恢复 Windows NTFS 中 EFS 加密文件

Advanced EFS Data Recovery 数据恢复软件可以破解 NTFS 加密&#xff0c;并解密受 Windows 加密文件系统 &#xff08;EFS&#xff09; 保护的文件。 Advanced EFS Data Recovery 功能列表 通过破解加密文件系统 &#xff08;EFS&#xff09; 来解除 NTFS 加密 解密转移到另…
阅读更多...
Java面试题(11)

Java面试题(11)

59.说一说springMVC的运行流程 1. 用户向服务器发送请求&#xff0c;请求被 Spring 前端控制 Servelt DispatcherServlet 捕获&#xff1b; 2. DispatcherServlet 对请求 URL 进行解析&#xff0c;得到请求资源标识符&#xff08;URI&#xff09;。然后根据该 URI&#xff0c;…
阅读更多...
STM32 E18-D80NK红外避障传感器

STM32 E18-D80NK红外避障传感器

E18-D80NK-N是一款红外光电传感器&#xff0c;它同时具备发射和接收功能。通过对发射光进行调制后发出&#xff0c;并通过接收头对反射光进行解调输出。 E18-D80NK-N采用了透镜来增强传感器的性能&#xff0c;使其能够检测更远的距离。根据红外光的特性&#xff0c;不同颜色的…
阅读更多...
最新文章

Copyright @ 2022~2023