Redis的分布式锁实现代码（商品秒杀）

最新推荐文章于 2024-06-19 18:10:55 发布
最新推荐文章于 2024-06-19 18:10:55 发布
阅读量219 收藏
点赞数
分类专栏： 学习技术成果 文章标签： redis java 分布式锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46488211/article/details/121124341
版权

Redis的分布式锁实现代码（商品秒杀）

准备工作

下载Apache JMeter软件：模拟多线程，高并发情况

导入依赖

导入redis包

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>

分布式锁代码

该方法有三个接口
①init()：初始化商品数量为100
②synchronizedBuy()：使用synchronizedBuy锁模拟商品秒杀
③redisBuy()：使用redis分布式锁模拟商品秒杀

@RestController
public class OrderController {

    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping("/initCount")
    public String init(){
        redisTemplate.opsForValue().set("count","100");
        return "库存初始化成功";
    }


    /**
     * @author:
     * @description: synchronized锁
     * @date: 2021/10/23
     * @param
     * @return java.lang.String
     */
    @GetMapping("/synchronizedBuy")
    public String synchronizedBuy(){
        synchronized (OrderController.class){
            Integer count = Integer.parseInt(redisTemplate.opsForValue().get("count").toString());
            if (count > 0)
            {
                Integer realCount = count - 1;
                System.out.println("购买商品成功，库存为：" + realCount.toString());
                redisTemplate.opsForValue().set("count",realCount.toString());
            }else {
                System.out.println("库存不足，购买失败");
            }
            return "ok";
        }
    }


    /**
     * @author:
     * @description: 使用分布式锁
     * @date: 2021/10/23
     * @param
     * @return java.lang.String
     */
    @GetMapping("/redisBuy")
    public String redisBuy(){
        String lockKey = "ShangPin";
        String clientId = UUID.randomUUID().toString();
        try {
            //setnx加锁
            //setIfAbsent()方法：如果这个锁已经存在，则返回flase，获得锁失败，如果返回true则说明加锁成功
            Boolean lock = redisTemplate.opsForValue().setIfAbsent(lockKey,clientId,10, TimeUnit.SECONDS);
            if (lock)
            {
                //执行购买业务
                int count1 = Integer.parseInt(redisTemplate.opsForValue().get("count").toString());
                if (count1 > 0)
                {
                    Integer realCount = count1 - 1;
                    System.out.println("购买商品成功，库存为：" + realCount.toString());
                    redisTemplate.opsForValue().set("count",realCount.toString());
                }else {
                    System.out.println("库存不足，购买失败");
                }
            }else {
                try {
                     //获取锁失败，每隔0.1秒再获取
                     Thread.sleep(100);
                     redisBuy();
                }catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //删锁,判断当前客户端的clientId与redis持有的一样
            if(clientId.equals(redisTemplate.opsForValue().get(lockKey)))
            redisTemplate.delete(lockKey);
        }
        return "ok";
    }
}

启动项目

为了模拟集群环境，idea需要启动两个端口不一样的服务，方法如下：
第一步
第二步
修改好后，端口为17055时启动项目
在这里插入图片描述
再把端口修改为17054，再次启动项目
在这里插入图片描述

启动Jmeter

使用Apache Jmeter软件模拟多线程并发。

Jmeter分别调用17055端口和17054端口的synchronizedBuy()接口和redisBuy()接口，分别模拟80个线程，以及17055端口的init()接口，具体配置如下。

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

调用17054的synchronizedBuy()接口
在这里插入图片描述
在这里插入图片描述
调用17055的synchronizedBuy()接口
在这里插入图片描述
其余几个接口可仿照上面内容进行创建。

运行结果

首先调用init()接口进行商品初始化操作。

单击环境下，使用synchronized锁

只调用一个接口，结果如下所示：
在这里插入图片描述
商品有100件，只模拟了80个线程，所有商品应该卖出80件，可以看出在单击环境下是哟synchronized锁没有问题。

购买商品成功，库存为：99
购买商品成功，库存为：98
购买商品成功，库存为：97
购买商品成功，库存为：96
购买商品成功，库存为：95
购买商品成功，库存为：94
购买商品成功，库存为：93
购买商品成功，库存为：92
购买商品成功，库存为：91
购买商品成功，库存为：90
购买商品成功，库存为：89
购买商品成功，库存为：88
购买商品成功，库存为：87
购买商品成功，库存为：86
购买商品成功，库存为：85
购买商品成功，库存为：84
购买商品成功，库存为：83
购买商品成功，库存为：82
购买商品成功，库存为：81
购买商品成功，库存为：80
购买商品成功，库存为：79
购买商品成功，库存为：78
购买商品成功，库存为：77
购买商品成功，库存为：76
购买商品成功，库存为：75
购买商品成功，库存为：74
购买商品成功，库存为：73
购买商品成功，库存为：72
购买商品成功，库存为：71
购买商品成功，库存为：70
购买商品成功，库存为：69
购买商品成功，库存为：68
购买商品成功，库存为：67
购买商品成功，库存为：66
购买商品成功，库存为：65
购买商品成功，库存为：64
购买商品成功，库存为：63
购买商品成功，库存为：62
购买商品成功，库存为：61
购买商品成功，库存为：60
购买商品成功，库存为：59
购买商品成功，库存为：58
购买商品成功，库存为：57
购买商品成功，库存为：56
购买商品成功，库存为：55
购买商品成功，库存为：54
购买商品成功，库存为：53
购买商品成功，库存为：52
购买商品成功，库存为：51
购买商品成功，库存为：50
购买商品成功，库存为：49
购买商品成功，库存为：48
购买商品成功，库存为：47
购买商品成功，库存为：46
购买商品成功，库存为：45
购买商品成功，库存为：44
购买商品成功，库存为：43
购买商品成功，库存为：42
购买商品成功，库存为：41
购买商品成功，库存为：40
购买商品成功，库存为：39
购买商品成功，库存为：38
购买商品成功，库存为：37
购买商品成功，库存为：36
购买商品成功，库存为：35
购买商品成功，库存为：34
购买商品成功，库存为：33
购买商品成功，库存为：32
购买商品成功，库存为：31
购买商品成功，库存为：30
购买商品成功，库存为：29
购买商品成功，库存为：28
购买商品成功，库存为：27
购买商品成功，库存为：26
购买商品成功，库存为：25
购买商品成功，库存为：24
购买商品成功，库存为：23
购买商品成功，库存为：22
购买商品成功，库存为：21
购买商品成功，库存为：20
集群环境下，使用synchronized锁

同时选中调用两个不同端口的synchronizedBuy()接口（ 模拟集群环境下使用synchronized锁实现商品秒杀的现象）
在这里插入图片描述
结果如下：在这里插入图片描述
在这里插入图片描述

购买商品成功，库存为：95
购买商品成功，库存为：94
购买商品成功，库存为：93
购买商品成功，库存为：92
购买商品成功，库存为：91
购买商品成功，库存为：90
购买商品成功，库存为：89
购买商品成功，库存为：88
购买商品成功，库存为：87
购买商品成功，库存为：86
购买商品成功，库存为：85
购买商品成功，库存为：84
购买商品成功，库存为：83
购买商品成功，库存为：82
购买商品成功，库存为：81
购买商品成功，库存为：80
购买商品成功，库存为：78
购买商品成功，库存为：77
购买商品成功，库存为：76
购买商品成功，库存为：75
购买商品成功，库存为：74
购买商品成功，库存为：73
购买商品成功，库存为：72
购买商品成功，库存为：71
购买商品成功，库存为：70
购买商品成功，库存为：69
购买商品成功，库存为：67
购买商品成功，库存为：65
购买商品成功，库存为：64
购买商品成功，库存为：62
购买商品成功，库存为：61
购买商品成功，库存为：60
购买商品成功，库存为：58
购买商品成功，库存为：57
购买商品成功，库存为：56
购买商品成功，库存为：55
购买商品成功，库存为：54
购买商品成功，库存为：53
购买商品成功，库存为：51
购买商品成功，库存为：50
购买商品成功，库存为：49
购买商品成功，库存为：48
购买商品成功，库存为：47
购买商品成功，库存为：46
购买商品成功，库存为：45
购买商品成功，库存为：43
购买商品成功，库存为：42
购买商品成功，库存为：40
购买商品成功，库存为：39
购买商品成功，库存为：38
购买商品成功，库存为：37
购买商品成功，库存为：36
购买商品成功，库存为：35
购买商品成功，库存为：34
购买商品成功，库存为：33
购买商品成功，库存为：32
购买商品成功，库存为：30
购买商品成功，库存为：28
购买商品成功，库存为：27
购买商品成功，库存为：25
购买商品成功，库存为：24
购买商品成功，库存为：23
购买商品成功，库存为：22
购买商品成功，库存为：21
购买商品成功，库存为：19
购买商品成功，库存为：18
购买商品成功，库存为：17
购买商品成功，库存为：15
购买商品成功，库存为：13
购买商品成功，库存为：12
购买商品成功，库存为：11
购买商品成功，库存为：10
购买商品成功，库存为：9
购买商品成功，库存为：8
购买商品成功，库存为：7
购买商品成功，库存为：6
购买商品成功，库存为：5
购买商品成功，库存为：4
购买商品成功，库存为：3
购买商品成功，库存为：2

购买商品成功，库存为：99
购买商品成功，库存为：98
购买商品成功，库存为：97
购买商品成功，库存为：96
购买商品成功，库存为：95
购买商品成功，库存为：94
购买商品成功，库存为：93
购买商品成功，库存为：92
购买商品成功，库存为：92
购买商品成功，库存为：91
购买商品成功，库存为：90
购买商品成功，库存为：89
购买商品成功，库存为：88
购买商品成功，库存为：87
购买商品成功，库存为：86
购买商品成功，库存为：85
购买商品成功，库存为：84
购买商品成功，库存为：83
购买商品成功，库存为：82
购买商品成功，库存为：80
购买商品成功，库存为：79
购买商品成功，库存为：78
购买商品成功，库存为：77
购买商品成功，库存为：76
购买商品成功，库存为：71
购买商品成功，库存为：70
购买商品成功，库存为：69
购买商品成功，库存为：68
购买商品成功，库存为：66
购买商品成功，库存为：65
购买商品成功，库存为：64
购买商品成功，库存为：63
购买商品成功，库存为：62
购买商品成功，库存为：61
购买商品成功，库存为：60
购买商品成功，库存为：59
购买商品成功，库存为：57
购买商品成功，库存为：56
购买商品成功，库存为：55
购买商品成功，库存为：54
购买商品成功，库存为：53
购买商品成功，库存为：52
购买商品成功，库存为：51
购买商品成功，库存为：50
购买商品成功，库存为：49
购买商品成功，库存为：48
购买商品成功，库存为：47
购买商品成功，库存为：46
购买商品成功，库存为：45
购买商品成功，库存为：44
购买商品成功，库存为：43
购买商品成功，库存为：42
购买商品成功，库存为：41
购买商品成功，库存为：40
购买商品成功，库存为：39
购买商品成功，库存为：38
购买商品成功，库存为：37
购买商品成功，库存为：36
购买商品成功，库存为：35
购买商品成功，库存为：34
购买商品成功，库存为：32
购买商品成功，库存为：31
购买商品成功，库存为：30
购买商品成功，库存为：29
购买商品成功，库存为：28
购买商品成功，库存为：27
购买商品成功，库存为：26
购买商品成功，库存为：25
购买商品成功，库存为：24
购买商品成功，库存为：23
购买商品成功，库存为：22
购买商品成功，库存为：21
购买商品成功，库存为：20
购买商品成功，库存为：19
购买商品成功，库存为：17
购买商品成功，库存为：16
购买商品成功，库存为：15
购买商品成功，库存为：14
购买商品成功，库存为：13
购买商品成功，库存为：12

可以看出商品已经超卖了。

集群环境下，使用redis分布式锁

在这里插入图片描述
运行结果：

在这里插入图片描述

购买商品成功，库存为：94
购买商品成功，库存为：93
购买商品成功，库存为：88
购买商品成功，库存为：87
购买商品成功，库存为：85
购买商品成功，库存为：83
购买商品成功，库存为：82
购买商品成功，库存为：81
购买商品成功，库存为：79
购买商品成功，库存为：73
购买商品成功，库存为：67
购买商品成功，库存为：62
购买商品成功，库存为：61
购买商品成功，库存为：58
购买商品成功，库存为：57
购买商品成功，库存为：56
购买商品成功，库存为：55
购买商品成功，库存为：50
购买商品成功，库存为：49
购买商品成功，库存为：47
购买商品成功，库存为：46
购买商品成功，库存为：45
购买商品成功，库存为：44
购买商品成功，库存为：43
购买商品成功，库存为：41
购买商品成功，库存为：40
购买商品成功，库存为：39
购买商品成功，库存为：38
购买商品成功，库存为：37
购买商品成功，库存为：34
购买商品成功，库存为：33
购买商品成功，库存为：32
购买商品成功，库存为：28
购买商品成功，库存为：27
购买商品成功，库存为：23
购买商品成功，库存为：22
购买商品成功，库存为：18
购买商品成功，库存为：17
购买商品成功，库存为：15
购买商品成功，库存为：14
购买商品成功，库存为：13
购买商品成功，库存为：12
购买商品成功，库存为：9
购买商品成功，库存为：8
购买商品成功，库存为：7
购买商品成功，库存为：4
购买商品成功，库存为：3
购买商品成功，库存为：2
库存不足，购买失败
库存不足，购买失败
库存不足，购买失败

购买商品成功，库存为：86
购买商品成功，库存为：84
购买商品成功，库存为：80
购买商品成功，库存为：78
购买商品成功，库存为：77
购买商品成功，库存为：76
购买商品成功，库存为：75
购买商品成功，库存为：74
购买商品成功，库存为：72
购买商品成功，库存为：71
购买商品成功，库存为：70
购买商品成功，库存为：69
购买商品成功，库存为：68
购买商品成功，库存为：66
购买商品成功，库存为：65
购买商品成功，库存为：64
购买商品成功，库存为：63
购买商品成功，库存为：60
购买商品成功，库存为：59
购买商品成功，库存为：54
购买商品成功，库存为：53
购买商品成功，库存为：52
购买商品成功，库存为：51
购买商品成功，库存为：48
购买商品成功，库存为：42
购买商品成功，库存为：36
购买商品成功，库存为：35
购买商品成功，库存为：31
购买商品成功，库存为：30
购买商品成功，库存为：29
购买商品成功，库存为：26
购买商品成功，库存为：25
购买商品成功，库存为：24
购买商品成功，库存为：21
购买商品成功，库存为：20
购买商品成功，库存为：19
购买商品成功，库存为：16
购买商品成功，库存为：11
购买商品成功，库存为：10
购买商品成功，库存为：6
购买商品成功，库存为：5
购买商品成功，库存为：1
购买商品成功，库存为：0
库存不足，购买失败
库存不足，购买失败

可以看出集群环境下使用redis分布式锁刚好买了100件商品，不会出现超卖现象。

.泡面.
关注
专栏目录
【Redis】实现购物秒杀及分布式锁
wmh的博客
01-31 917
分布式锁：满足分布式系统或集群模式下多进程可见并且互斥的锁。使用一个独立于JVM的锁监视器（分布式锁），让所有集群的JVM共享一个锁监视器，使得只有一个线程运行。Redisson是一个分布式操作 Redis 的 Java 客户端（分布式 Redis 数据网格），可以像在使用本地的集合一样操作 Redis。Redisson还提供了许多分布式服务，其中就包含了各种分布式锁的实现。Redisson 官网消息队列（Message Queue）：存放消息的队列。
基于redis分布式锁实现“秒杀”
热门推荐
刘劭的博客
12-18 21万+
最近在项目中遇到了类似“秒杀”的业务场景，在本篇博客中，我将用一个非常简单的demo，阐述实现所谓“秒杀”的基本思路。 业务场景 所谓秒杀，从业务角度看，是短时间内多个用户“争抢”资源，这里的资源在大部分秒杀场景里是商品；将业务抽象，技术角度看，秒杀就是多个线程对资源进行操作，所以实现秒杀，就必须控制线程对资源的争抢，既要保证高效并发，也要保证操作的正确。 一些可能的实现 刚才提到
如何借助 Redis 实现秒杀系统？
程序IT圈
12-11 490
来源：http://t.cn/EtMiR33最近在项目中遇到了类似“秒杀”的业务场景，在本篇博客中，我将用一个非常简单的demo，阐述实现所谓“秒杀”的基本思路。业务场景所谓秒杀，从业务...
【Redis】基于Redisson实现分布式锁（代码实现）
最新发布
m0_64210833的博客
06-19 1630
基于Redisson实现分布式锁解决商品秒杀超卖的场景,包含测试代码。
redis分布式锁实现代码
02-28
使用命令介绍： SETNX SETNX key val 当且仅当key不存在时，set一个key为val的字符串，返回1；若key存在，则什么都不做，返回0。 expire expire key timeout 为key设置一个超时时间，单位为second，超过这个时间锁会自动释放，避免死锁。 delete delete key 删除key
redis分布式锁代码实现
突发7想的专栏
08-14 202
实现目标 保证获取锁和释放锁操作的原子性； 保证锁在应用异常时能自动释放； 保证多线程情况，不会被其他线程提前释放； 获取锁 /** * 尝试获取分布式锁 * * @param lockKey 锁 * @param requestId 请求标识 * @param expireTime 超期时间, 秒 * @return 是否获取成功 */ public boolean requireLock(String lockKey, String requestId, int expireT
Redis实现分布式锁的代码实现
weixin_59287292的博客
02-21 972
redis实现分布式锁的代码逻辑
java基于jedisLock—redis分布式锁实现示例代码
08-28
"java基于jedisLock—redis分布式锁实现示例代码" java基于jedisLock—redis分布式锁实现示例代码主要介绍了jedisLock—redis分布式锁实现示例代码，以下是对标题和描述中所说的知识点的详细说明： 分布式锁是啥？...
C#实操控制并发之Lock和Redis分布式锁
01-21
在秒杀场景中，使用Redis分布式锁可以确保全局唯一性，避免多个用户同时购买同一商品，保护库存数据的准确性和一致性。 总的来说，C#中的Lock适用于单机环境的并发控制，而Redis分布式锁则适用于分布式系统，确保多...
Redis分布式锁实现方式及超时问题解决
08-19
本文主要介绍了Redis分布式锁实现方式及超时问题解决，通过详细的示例代码和实现原理，帮助读者理解分布式锁的应用场景和实现方式，并解决分布式锁常见的问题。 一、分布式锁的产生背景 分布式锁是为了解决多个...
基于Redis分布式锁的实现代码
12-16
概述 目前几乎很多大型网站及应用都是分布式部署的，分布式场景中的数据一致性问题一直是一个比较重要的话题。分布式的CAP理论告诉我们“任何一个分布式系统都无法同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance），最多只能同时满足两项。”所以，很多系统在设计之初就要对这三者做出取舍。在互联网领域的绝大多数的场景中，都需要牺牲强一致性来换取系统的高可用性，系统往往只需要保证“最终一致性”，只要这个最终时间是在用户可以接受的范围内即可。 在很多场景中，我们为了保证数据的最终一致性，需要很多的技术方案来支持，比如分布式事务、分
基于redis分布式锁实现秒杀功能
01-19
最近在项目中遇到了类似“秒杀”的业务场景，在本篇博客中，我将用一个非常简单的demo，阐述实现所谓“秒杀”的基本思路。 业务场景 所谓秒杀，从业务角度看，是短时间内多个用户“争抢”资源，这里的资源在大部分秒杀场景里是商品；将业务抽象，技术角度看，秒杀就是多个线程对资源进行操作，所以实现秒杀，就必须控制线程对资源的争抢，既要保证高效并发，也要保证操作的正确。 一些可能的实现 刚才提到过，实现秒杀的关键点是控制线程对资源的争抢，根据基本的线程知识，可以不加思索的想到下面的一些方法： 1、秒杀在技术层面的抽象应该就是一个方法，在这个方法里可能的操作是将商品库存-1，将商品加入用户的购物车等等，在不
springboot redis分布式锁代码实例
08-25
SpringBoot Redis分布式锁代码实例是指通过SpringBoot框架和Redis数据库来实现分布式锁的机制。分布式锁是指在分布式系统中，多个节点或进程需要访问共享资源时，为了避免冲突和竞争，使用锁机制来保护这些资源。...
redis分布式锁的原理与实现【分布式】
weixin_44545838的博客
05-31 2210
分布式锁是指在分布式系统中，为了实现协调和同步访问共享资源，而对分布式环境下的多个进程或线程进行同步的一种机制。它可以保证在分布式环境下各进程访问共享资源的时序一致性和互斥性，避免不同进程之间发生冲突。基于数据库的分布式锁：使用数据库的事务机制来实现分布式锁，通过在数据库插入一个唯一的记录来实现锁定，其他进程尝试并发获取锁时会阻塞等待。基于缓存的分布式锁。
基于redis集群实现的分布式锁,可用于秒杀,定时器。
weixin_33697898的博客
10-12 164
在分布式系统中，经常会出现需要竞争同一资源的情况,使用redis可以实现分布式锁。 前提：redis集群已经整合项目，并且可以直接注入JedisCluster使用： @Autowired private JedisCluster jedisCluster;   1. 新建RedisLockManger分布式锁管理器，并且如上注入 JedisCluster : package ...
Redis分布式锁代码实现(Java)
zxyhj的博客
11-07 1055
【代码】Redis分布式锁代码实现(Java)
redis分布式锁java代码_基于redis实现分布式锁
weixin_39743511的博客
12-08 87
“在上一篇文章中介绍了动态配置定时任务，其中的原理跟spring 定时任务注解@Scheduled一样的，都是通过线程池和定义执行时间来控制。来思考一个问题，如果我们的定时任务在分布式微服务里面呢？在分布式微服务里面一个微服务肯定可以有多个实例的，在上一篇文章当中配置的定时任务就会有可能存在多个，显然定时任务被多次执行并不是我们想要的结果，这个时候我们的分布式锁机制就出现了！”(分布式...
java代码结合redis分布式锁实现秒杀功能
05-09
下面是一个简单的Java代码，结合Redis分布式锁实现秒杀功能： ```java public class RedisLock { private static final String LOCK_PREFIX = "redis_lock_"; private JedisPool jedisPool; public RedisLock(JedisPool jedisPool) { this.jedisPool = jedisPool; } /** * 获取锁 * @param lockName 锁名称 * @param timeout 超时时间，单位为秒 * @return 是否获取到锁 */ public boolean lock(String lockName, int timeout) { Jedis jedis = null; try { jedis = jedisPool.getResource(); String lockKey = LOCK_PREFIX + lockName; long start = System.currentTimeMillis(); while (true) { String result = jedis.set(lockKey, "locked", "NX", "EX", timeout); if ("OK".equals(result)) { return true; } long end = System.currentTimeMillis(); if ((end - start) > (timeout * 1000 - 100)) { return false; } Thread.sleep(100); } } catch (Exception e) { e.printStackTrace(); } finally { if (jedis != null) { jedis.close(); } } return false; } /** * 释放锁 * @param lockName 锁名称 * @return 是否释放成功 */ public boolean release(String lockName) { Jedis jedis = null; try { jedis = jedisPool.getResource(); String lockKey = LOCK_PREFIX + lockName; jedis.del(lockKey); return true; } catch (Exception e) { e.printStackTrace(); } finally { if (jedis != null) { jedis.close(); } } return false; } } ``` 接下来是使用Redis锁实现的秒杀功能的代码示例： ```java public class SeckillService { private RedisLock redisLock; public SeckillService(RedisLock redisLock) { this.redisLock = redisLock; } /** * 秒杀商品 * @param productId 商品ID * @param userId 用户ID * @return 是否秒杀成功 */ public boolean seckill(String productId, String userId) { boolean lockResult = redisLock.lock(productId, 10); // 获取锁 if (!lockResult) { return false; // 没有获取到锁，表示秒杀失败 } try { // TODO: 执行秒杀操作 return true; // 秒杀成功 } finally { redisLock.release(productId); // 释放锁 } } } ``` 在使用Redis分布式锁时，需要特别注意以下几点： 1. 锁的名称要尽可能唯一，以免与其他锁发生冲突。 2. 锁的超时时间应该设置得足够短，避免因为锁一直被占用而导致其他请求无法执行。 3. 在获取锁时，需要使用set命令的NX和EX选项，避免因为竞争而导致的死锁问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值