REDIS14_分布式锁的概述、加锁使用sexnu、解锁使用lua脚本保证原子性、引发的问题思考

已于 2023-03-07 21:47:10 修改
阅读量1k 收藏 7
点赞数 5
分类专栏： REDIS6高性能缓存 文章标签： lua redis 数据库
于 2021-08-31 17:38:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TZ845195485/article/details/120022331
版权

文章目录

①. 分布式锁的概述

  • ①. 锁的种类
  1. 单机版同一个JVM虚拟机内,synchronized或者Lock接口
  2. 分布式不同个JVM虚拟机内,单机的线程锁机制不再起作用,资源类在不同的服务器之间共享了
  • ②. 一个靠谱分布式锁需要具备的条件和刚需 (掌握)
  1. 独占性:任何时刻只能有且仅有一个线程持有
  2. 高可用:若redis集群环境下,不能因为某一个节点挂了而出现获取锁和释放锁失败的情况
  3. 防死锁:杜绝死锁,必须有超时控制机制或者撤销操作,有个兜底终止跳出方案
  4. 不乱抢:防止张冠李戴,不能私下unlock别人的锁,只能自己加锁自己释放。
  5. 重入性:同一个节点的同一个线程如果获得锁之后,它也可以再次获取这个锁。

在这里插入图片描述在这里插入图片描述

②. 分布式锁的案例搭建

  • ①. 建Module boot_redis01、boot_redis02

  • ②. 改POM

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.10.RELEASE</version>
        <relativePath/>
    </parent>

    <groupId>com.xiaozhi.redis</groupId>
    <artifactId>boot_redis01</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--guava-->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>23.0</version>
        </dependency>
        <!--web+actuator-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--SpringBoot与Redis整合依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <!-- jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.1.0</version>
        </dependency>
        <!-- springboot-aop 技术-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!-- redisson -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.13.4</version>
        </dependency>
        <!--一般通用基础配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
  • ③. 写yml
# 端口号
server.port=1111
# ========================redis相关配置=====================
# Redis数据库索引(默认为0)
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=192.168.56.10
# Redis服务器连接端口
spring.redis.port=6379  
# Redis服务器连接密码(默认为空)
spring.redis.password=
# 连接池最大连接数(使用负值表示没有限制) 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间(使用负值表示没有限制) 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0
  • ④. 配置类config
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Serializable> redisTemplate(LettuceConnectionFactory connectionFactory){
        RedisTemplate<String, Serializable> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate;
    }
}
  • ⑤. 业务类
@RestController
public class GoodController{
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/buy_goods")
    public String buy_Goods(){
        String result = stringRedisTemplate.opsForValue().get("goods:001");
        int goodsNumber = result == null ? 0 : Integer.parseInt(result);

        if(goodsNumber > 0){
            int realNumber = goodsNumber - 1;
            stringRedisTemplate.opsForValue().set("goods:001",realNumber + "");
            System.out.println("你已经成功秒杀商品,此时还剩余:" + realNumber + "件"+"\t 服务器端口:"+serverPort);
            return "你已经成功秒杀商品,此时还剩余:" + realNumber + "件"+"\t 服务器端口:"+serverPort;
        }else{
            System.out.println("商品已经售罄/活动结束/调用超时,欢迎下次光临"+"\t 服务器端口:"+serverPort);
        }
        return "商品已经售罄/活动结束/调用超时,欢迎下次光临"+"\t 服务器端口:"+serverPort;
    }
}

③. 使用sexnx+lua脚本解决

  • ①. 没有加锁,并发下数字不对,出现超卖现象,可以加上lock和synchronized来解决,不适合分布式的情况

  • ②. 使用分布式锁setIfAbsent来解决

    @GetMapping("/buy_goods")
    public String buy_Goods() {
        String key = "RedisLock";
        String value = UUID.randomUUID().toString()+Thread.currentThread().getName();
			 // setIfAbsent是java中的方法
			 // setnx是redis命令中的方法
        Boolean flagLock = stringRedisTemplate.opsForValue().setIfAbsent(key, value);
        if(!flagLock) {
            return "抢夺锁失败";
        }

        String result = stringRedisTemplate.opsForValue().get("goods:001");
        int goodsNumber = result == null ? 0 : Integer.parseInt(result);

        if(goodsNumber > 0)
        {
            int realNumber = goodsNumber - 1;
            stringRedisTemplate.opsForValue().set("goods:001",realNumber + "");
            stringRedisTemplate.delete(key);
            System.out.println("你已经成功秒杀商品,此时还剩余:" + realNumber + "件"+"\t 服务器端口:"+serverPort);
            return "你已经成功秒杀商品,此时还剩余:" + realNumber + "件"+"\t 服务器端口:"+serverPort;
        }else{
            System.out.println("商品已经售罄/活动结束/调用超时,欢迎下次光临"+"\t 服务器端口:"+serverPort);
        }

        return "商品已经售罄/活动结束/调用超时,欢迎下次光临"+"\t 服务器端口:"+serverPort;
    }
  • ③. 在②的情况下,如果出异常的话,可能无法释放锁,必须要在代码层面finally释放锁
    在这里插入图片描述
  • ④. 部署了微服务jar包的机器挂了,代码层面根本没有走到finally这块,没办法保证解锁,这个key没有被删除,需要加入一个过期时间限定key
   Boolean flagLock = stringRedisTemplate.opsForValue().setIfAbsent(key, value);//1
   stringRedisTemplate.expire(key,10L,TimeUnit.SECONDS);//2
  • ⑤. 设置key+过期时间分开了,必须要合并成一行具备原子性(加锁必须确保原子性)
    在④中,如果某一个时刻,刚刚执行完//1,这个时候发生宕机,那么就造成了死锁
    stringRedisTemplate.opsForValue().setIfAbsent(key,value,10L,TimeUnit.SECONDS);
  • ⑥. 张冠李戴,删除了别人的锁
    如果线程A拿到分布式锁,设置的过期时间小于业务代码执行的时间,当A线程分布式锁刚刚过期,这个时候B线程获取到了分布式锁,A线程执行完业务逻辑,进行删除,就可能删除的是B的分布式锁
finally {
  if (stringRedisTemplate.opsForValue().get(key).equals(value)) {
      stringRedisTemplate.delete(key);
  }
}
  • ⑦. 基于⑥的操作也有问题,finally块的判断+del删除操作不是原子性的
    在这里插入图片描述
  • ⑧. 用Lua脚本,删除保证原子性
   //1.占分布式锁,去redis占坑  setIfAbsent==sexnx
   //Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "111");
   //redisTemplate.expire("lock",30,TimeUnit.SECONDS);
   String uuid = UUID.randomUUID().toString();
   Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid,300,TimeUnit.SECONDS);
   if(lock){
       Map<String, List<Catelog2Vo>> dataFromDb=null;
       try{
           //加锁成功,执行业务
           dataFromDb = getDataFromDb();
       }finally {
           //原子删锁
           String script = "if redis.call('get', KEYS[1]) == ARGV[1] " +
                   "then " +
                   "return redis.call('del', KEYS[1]) " +
                   "else " +
                   "   return 0 " +
                   "end";
           //删除成功返回1,删除不成功返回0
           redisTemplate.execute(
                   new DefaultRedisScript<Long>(script,Long.class),
                   Arrays.asList("lock"),uuid);
       }
       return dataFromDb;
   }else{
       //加锁失败....重试
       try { TimeUnit.SECONDS.sleep(1);  } catch (InterruptedException e) {e.printStackTrace();}
       return getCatalogJsonFromDbWithRedisLock();
   }

④. 问题总结 - 推出分布式锁

  • ①. synchronized单机版OK,上分布式

  • ②. nginx分布式微服务,单机锁不行

  • ③. 取消单机锁,上redis分布式锁setnx

  • ④. 只加了锁,没有释放锁,出异常的话,可能无法释放锁,必须要在代码层面finally释放锁

  • ⑤. 宕机了,部署了微服务代码层面根本没有走到finally这块,没办法保证解锁,这个key没有被删除,需要有lockKey的过期时间设定

  • ⑥.为redis的分布式锁key,增加过期时间此外,还必须要setnx+过期时间必须同一行

  • ⑦. 必须规定只能自己删除自己的锁,你不能把别人的锁删除了,防止张冠李戴,1删2,2删3

  • ⑧. redis集群环境下,我们自己写的也不OK,直接上RedLock之Redisson落地实现

⑤. Redis单机CP、集群AP、EurekaAP、Zookeeper集群CP

  • ①. Redis单机是CP,集群是AP
    在这里插入图片描述

  • ②. Redis集群:AP
    (redis异步复制造成的锁丢失,比如:主节点没来的及把刚刚set进来这条数据给从节点,master就挂了,从机上位但从机上无该数据)

  • ③. Zookeeper集群的CP
    在这里插入图片描述在这里插入图片描述

  • ④. Eureka是AP
    在这里插入图片描述

⑥. 单机的Redis案例加锁、解锁

  • ①. 加锁:加锁实际上就是在redis中,给Key键设置一个值,为避免死锁,并给定一个过期时间

  • ②. 解锁:将Key键删除。但也不能乱删,不能说客户端1的请求将客户端2的锁给删除掉,只能自己删除自己的锁
    (为了保证解锁操作的原子性,我们用LUA脚本完成这一操作。先判断当前锁的字符串是否与传入的值相等,是的话就删除Key,解锁成功)

if redis.call('get',KEYS[1]) == ARGV[1] then 
   return redis.call('del',KEYS[1]) 
else
   return 0 
end

  • ③. 超时:锁key要注意过期时间,不能长期占用

  • ④. 单机模式中,一般都是用set/setnx+lua脚本搞定,想想它的缺点是什么？
    如果redis发生了宕机,所有的请求压力都指向了数据库

public Map<String, List<Catalog2Vo>> getCatalogJsonDbWithRedisLock() {
    String uuid = UUID.randomUUID().toString();
    ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
    Boolean lock = ops.setIfAbsent("lock", uuid,500, TimeUnit.SECONDS);
    if (lock) {
        Map<String, List<Catalog2Vo>> categoriesDb = getCategoryMap();
        String lockValue = ops.get("lock");
        // get和delete原子操作
        String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1] then\n" +
            "    return redis.call(\"del\",KEYS[1])\n" +
            "else\n" +
            "    return 0\n" +
            "end";
        stringRedisTemplate.execute(
            new DefaultRedisScript<Long>(script, Long.class), // 脚本和返回类型
            Arrays.asList("lock"), // 参数
            lockValue); // 参数值,锁的值
        return categoriesDb;
    }else {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 睡眠0.1s后,重新调用 //自旋
        return getCatalogJsonDbWithRedisLock();
    }
}
所得皆惊喜
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
使用redis+lua脚本实现分布式锁
不能说的秘密的博客
04-15 6208
分布式锁的应用场景 当多个机器（多个进程）会对同一条数据进行修改时，并且要求这个修改是原子性的。这里有两个限定： 多个进程之间的竞争，意味着JDK自带的锁失效； 原子性修改，意味着数据是有状态的，修改前后有依赖。 本文将先介绍Redis的实现方式，后面笔者会介绍分布式锁的其他实现。 在学习Redis实现分布式锁的过程中，笔者首先参考了Redis的官方文档实现Red...
Redis：代码实战之锁和原子操作
张豫湘的博客
04-09 472
第三步：完成了与所有实例的加锁操作之后需要计算整个过程的耗时，用于比较锁的过期时间，如果请求锁的时间大于了过期时间，则将该锁释放，如果客户端请求成功的实例不占大多数，也会释放锁。解决办法：区分当前锁是那个客户端申请的，其实就是给锁的变量设置一个唯一id进行客户端的区分，删除的时候也比较这个值是不是和申请锁的客户端的唯一id相等，相等才能执行删除锁操作。删除锁变量，释放锁过程包含了读取锁变量、判断值、删除锁变量多个操作，因此使用Lua脚本，原子性的方式执行保证释放锁操作的原子性。
基于 Redis + Lua 脚本实现分布式锁，确保操作的原子性
Java Punk
12-16 9431
Lua脚本是高并发、高性能的必备脚本语言，大部分的开源框架（如：redission）中的分布式锁组件，都是用纯lua脚本实现的。
Redis缓存系列：为什么redis是单线程的
一天不写代码难受的博客
09-15 159
分布式解锁为什么需要保证原子性
chang_ye98的博客
09-10 476
解锁操作的原子性 客户端 A 获取锁成功； 客户端 A 访问共享资源； 客户端 A 为了释放锁，先执行 GET 操作获取锁对应的随机字符串的值； 客户端 A 判断随机字符串的值，与预期的值相等； 客户端 A 由于某个原因阻塞了很长时间； 过期时间到了，锁自动释放了； 客户端 B 获取到了对应同一个资源的锁； 客户端 A 从阻塞中恢复过来，执行 DEL 操纵，释放掉了客户端 B 持有的锁。 如下图 解决方法：使用Lua脚本进行解锁 ...
redis实现分布式锁,自旋式加锁,lua原子性解锁
07-16
本文将深入探讨如何使用Redis实现分布式锁，以及如何利用自旋式加锁和Lua脚本实现原子性解锁。 首先，我们来理解分布式锁的基本概念。分布式锁是在多节点之间共享资源时，用于协调各个节点的访问控制机制。在分布式...
SpringBoot 使用 Redis 分布式锁解决并发问题.docx
04-25
对于较低版本的SpringBoot，可以使用Lua脚本来保证原子性，因为Redis服务器会将整个Lua脚本作为一个原子操作执行。以下是一个简化的`RedisLock`工具类示例： ```java @Component public class RedisLock { @...
Redis Template实现分布式锁的实例代码
09-09
注意，这里的代码没有包含完整的解锁逻辑，实际应用中，解锁过程同样重要，可能需要使用`DEL`命令删除键，或者在某些情况下使用`lua`脚本来保证解锁操作的原子性。 **总结** Redis分布式锁通过`Redis Template`的...
使用Redis实现分布式锁.zip
06-06
为解决这个问题，可以使用`lua`脚本确保获取锁操作的原子性，同时在释放锁时检查是否过期，避免死锁。 3. **可重入性**：为了允许同一个客户端重新获取已持有的锁，可以在锁的实现中加入客户端ID，每次获取锁时检查...
浅谈分布式锁的几种使用方式（redis、zookeeper、数据库）
09-09
另外，使用`lua`脚本可以保证原子性，避免竞态条件。在Redis中，还可以实现公平锁，通过队列管理锁的请求顺序。 再者，Zookeeper也是实现分布式锁的一种选择。Zookeeper是一个分布式协调服务，提供诸如命名服务、...
为什么redis可以做分布式锁，是因为redis是单线程的吗?
m0_50180963的博客
02-24 3172
作者：bravo1988 链接：https://www.zhihu.com/question/317687988/answer/1715863550 来源：知乎 这个回答更注重解释是什么，适合对Redis分布式锁完全没概念的同学。如果你已经有Redis分布式锁使用经验，可以不用看。 我发现知乎戾气真重，什么乱七八糟的人都有。如果你觉得这回答不是你期望的，左滑退出就好了，干嘛非要浪费自己的时间看完然后评论一句：什么都没讲明白。这不是为难自己吗... 不论面试还是实际工作中，Redis都是避无可避的技.
Redis单线程为什么需要加锁
qq_39612954的博客
10-19 4307
首先需要说明一点的是：我们一直在强调 redis 是单线程，只是在处理我们的网络请求的时候只有一个线程来处理，一个正式的Redis Server运行的时候肯定是不止一个线程的。 为什么redis是单线程的？   官方FAQ表示，因为Redis是基于内存的操作，CPU不是Redis的瓶颈，Redis的瓶颈最有可能是机器内存的大小或者网络带宽。既然单线程容易实现，而且CPU不会成为瓶颈，那就顺理成章地采用单线程的方案了。 为什么redis需要加锁？   我们需要注意的是：redis是单线程这是毋庸置疑的。red
求求你，别再开发的时候一用redis分布式锁，就急着去复制粘贴了！lua脚本的实现思路
皇甫嗷嗷叫
06-25 370
随着业务越来越负责，现在的业务，能够支持分布式和高并发是基本的要求，涉及到高并发和分布式就一定会涉及到分布式锁机制，分布式锁就是为了保证分布式环境下，只有一个机器能够拿到锁对象，其余的都需等待该锁释放，再进行申请锁资源！ 分布式锁必须遵循以下原则： 同一时刻只能有一个机器（进程或线程）能够拿到锁对象！ 拥有过期机制，防止机器宕机没有释放锁的情况下造成死锁！ 加锁和解锁的必须是一个机器（线程、进程）！ 集群环境下，存活机器依旧何以做完整的加解锁操作！ 一、思路图 二、思路图实现 1.正确实现 该实现由
为 android编译 luajit库、 交叉编译
u014686778的博客
07-17 540
NDK路径/toolchains/arm-linux-androideabi-4.9/prebuilt/darwin-x86_64/bin/arm-linux-androideabi-gcc --sysroot=NDK路径/platforms/android-21/arch-arm -isystem NDK路径/sysroot/usr/include -isystem NDK路径/sysroot/usr/include/arm-linux-androideabi -pie -o main main.c。
[Redis]典型应用——分布式锁
a_zhee1的博客
07-19 411
介绍redis的典型应用——分布式锁
【字幕】字幕特效入门
RockWang的博客
07-17 392
字幕特效
lua 游戏架构 之 资源加载 LoaderManager (一)
heyuchang666的专栏
07-17 631
通过对象池管理资源加载器，可以减少对象的频繁创建和销毁，提高性能
Lua 运算符
lsx202406的博客
07-16 485
Lua 是一种轻量级的编程语言，广泛用于游戏开发、脚本编写和其他应用程序。它具有一套丰富的运算符，用于执行各种数学和逻辑操作。本文将详细介绍 Lua 中的运算符，包括算术运算符、关系运算符、逻辑运算符和其他特殊运算符。
lua 游戏架构 之 SceneLoad场景加载（一）
最新发布
heyuchang666的专栏
07-19 172
设计一个为`BaseSceneLoad` class，用于处理场景加载的相关操作 ，主要作用是提供了一个通用的场景加载框架
redis hincrby 原子性判断_Redis系列分布式锁
06-09
好的，你的第一个问题是关于 Redis 分布式锁的。在 Redis 中，可以使用 SETNX 命令创建一个分布式锁，但是这种方式存在一些问题，比如锁不具备自动过期，如果客户端在获取锁之后崩溃了，则锁可能无法释放，从而导致死锁等问题。 为了解决这些问题，可以使用 Redlock 算法或者基于 Redis 的 Redission 分布式锁。这些锁的实现方式都是基于 Redis 原子操作的特性，比如使用 Lua 脚本实现分布式锁的创建和释放，或者使用 Redis 的事务机制实现分布式锁的加锁和解锁。其中，Redlock 算法是一个多节点锁的实现方式，更加安全可靠，但是性能方面可能会受到一些影响。 另外，如果只是需要实现一个简单的分布式锁，也可以使用 Redis 的 INCR 和 EXPIRE 命令实现。具体来说，可以使用 INCR 命令对一个指定的键值进行自增操作，如果自增后的值为 1，则表示获取到了锁，否则表示锁已经被其他客户端占用。此外，还可以使用 EXPIRE 命令为锁设置一个过期时间，以防止锁一直被占用而导致死锁。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

所得皆惊喜

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值