Redis 分布式锁

最新推荐文章于 2024-01-30 14:38:54 发布
最新推荐文章于 2024-01-30 14:38:54 发布
阅读量335 收藏
点赞数 1
分类专栏： 分布式系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33537014/article/details/119011899
版权

Redis 分布式锁

前提条件：

初始库存：50
请添加图片描述

SpringBoot工程搭建：

  1. pom.xml依赖
<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	<!-- springboot整合redis-->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-data-redis</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
</dependencies>
  1. application.yaml配置
server:
  port: 8081

spring:
  redis:
    host: 192.168.216.129
    port: 6379
1、单机场景下，请问会出现超卖场景？
@RestController
public class StockController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @RequestMapping("/distributed-lock/substract-stock")
    public String subtractStock() {
        String stockKey = "stock";
        int stock = Integer.parseInt(Objects.requireNonNull(stringRedisTemplate.opsForValue().get(stockKey)));
        if (stock > 0) {
            stock = stock - 1;
            stringRedisTemplate.opsForValue().set(stockKey, stock + "");
            System.out.println("减库存成功,当前库存:" + stock);
        } else {
            System.out.println("库存不足");
        }
        return "succees";
    }
}

理论分析：

请添加图片描述

压测结果（利用jmeter工具，模拟100个线程同时访问该接口，并测10组下的结果）：

请添加图片描述

jmeter配置如下：

  • Thread Group配置

请添加图片描述

  • Http Request配置

请添加图片描述

  • Aggregate Report配置，保存报告生成位置

请添加图片描述

解决方案：

使用synchronized同步代码块，即可。

请添加图片描述

压测结果（无超卖）：

请添加图片描述

2、分布式场景下，请问会出现超卖场景？

负债均衡架构：

请添加图片描述

	@RequestMapping("/distributed-lock/substract-stock")
    public String subtractStock() {
        String stockKey = "stock";
        synchronized (this) {
            int stock = Integer.parseInt(Objects.requireNonNull(stringRedisTemplate.opsForValue().get(stockKey)));
            if (stock > 0) {
                stock = stock - 1;
                stringRedisTemplate.opsForValue().set(stockKey, stock + "");
                System.out.println("减库存成功,当前库存:" + stock);
            } else {
                System.out.println("库存不足");
            }
        }
        return "succees";
    }

理论分析：

会出现超卖场景，因为synchronized锁住的代码块，仅生效于单个服务器上，多个服务器之间，锁是不生效的。代表两个服务器之间可能获取到redis同一条数据，再在同一条数据上做减库存操作，出现超卖。

IDEA修改端口号及修改启动方式支持平行，快速开启两个tomcat服务：

请添加图片描述

jmeter修改访问地址为nginx地址：

请添加图片描述

压测结果（超卖，发现两台服务器出现相同的库存，代表同一时刻获取到了一样的库存，再做减库存操作）：

请添加图片描述
请添加图片描述

3、分布式场景下超卖现象如何解决呢？

方案架构图：

请添加图片描述

3.1 解决方案一：利用SETNX

方案详解：

SETNX：当给锁指定的key设值时，若key不存在，则设置成功，返回1。相反，若key存在，则设置失败，返回0。

利用该思路，我们设计一个共同标识，加锁相当于执行SETNX，加锁成功，返回1，执行业务，相反，设值失败，代表别的线程正在执行，该线程等待。解锁相当于删除共同标识，让别的线程可以重新得到锁。

代码修改第一版：

@RestController
public class StockController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @RequestMapping("/distributed-lock/substract-stock")
    public String subtractStock() {
        // 分布式锁key定义
        String redisLock = "distributed-lock";
        // 设值一个唯一标识,保障改线程仅能释放自己加的锁,不能释放别的线程的锁
        UUID clientId = UUID.randomUUID();
        String stockKey = "stock";
        try {
            // 相当于执行 setnx distributed-lock lock
            Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(redisLock, clientId.toString());
            // 设值失败,相当于没有得到锁,通过自旋方式尝试获得锁
            if (!result) {
                // 如果没有抢到锁,返回一个错误码,让前台做友好提示
                return "error";
            }
            // 减库存
            int stock = Integer.parseInt(Objects.requireNonNull(stringRedisTemplate.opsForValue().get(stockKey)));
            if (stock > 0) {
                stock = stock - 1;
                stringRedisTemplate.opsForValue().set(stockKey, stock + "");
                System.out.println("减库存成功,当前库存:" + stock);
            } else {
                System.out.println("库存不足");
            }
            return "succees";
        } finally {
            // 仅加锁的线程,能够释放该锁
            if (clientId.toString().equals(stringRedisTemplate.opsForValue().get(redisLock))) {
                // 放在finally中执行,保障异常场景下,锁能够得到释放
                stringRedisTemplate.delete(redisLock);
            }
        }
    }
}

压测结果（无超卖）：

请添加图片描述

请添加图片描述

想想上述代码可能还有那些问题？

问题：

因为setnx设置的key是永久的，代表如果线程A获得锁，迟迟不释放，比如运行10多分钟都不释放，那么别的线程都得不到锁，整个服务就无法正常对外提供。

如何解决：

问题点在key是永久的，那么给key设置一个过期时间，比如30s，当线程A如果30s内仍然不释放锁，那么key过期，别的线程依旧能够正常获取到锁，正常往下执行。

解决代码如下：

@RestController
public class StockController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @RequestMapping("/distributed-lock/substract-stock")
    public String subtractStock() {
        // 分布式锁key定义
        String redisLock = "distributed-lock";
        // 设值一个唯一标识,保障改线程仅能释放自己加的锁,不能释放别的线程的锁
        UUID clientId = UUID.randomUUID();
        String stockKey = "stock";
        try {
            // 相当于执行 setnx distributed-lock lock
            Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(redisLock, clientId.toString());
            // 设值过期时间为30s
            stringRedisTemplate.expire(redisLock, 30, TimeUnit.MILLISECONDS);
            // 设值失败,相当于没有得到锁,通过自旋方式尝试获得锁
            if (!result) {
                // 如果没有抢到锁,返回一个错误码,让前台做友好提示
                return "error";
            }
            // 减库存
            int stock = Integer.parseInt(Objects.requireNonNull(stringRedisTemplate.opsForValue().get(stockKey)));
            if (stock > 0) {
                stock = stock - 1;
                stringRedisTemplate.opsForValue().set(stockKey, stock + "");
                System.out.println("减库存成功,当前库存:" + stock);
            } else {
                System.out.println("库存不足");
            }
            return "succees";
        } finally {
            // 仅加锁的线程,能够释放该锁
            if (clientId.toString().equals(stringRedisTemplate.opsForValue().get(redisLock))) {
                // 放在finally中执行,保障异常场景下,锁能够得到释放
                stringRedisTemplate.delete(redisLock);
            }
        }
    }
}

想想上述代码是否还有问题？

问题：

// 相当于执行 setnx distributed-lock lock
Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(redisLock, clientId.toString());
// 设值过期时间为30s
stringRedisTemplate.expire(redisLock, 30, TimeUnit.MILLISECONDS);

由于上述两段代码不是原子执行的，所以有可能第一个方法执行完，系统宕机，那么也会出现锁得不到释放。

解决办法：

将两个方法，提成原子执行即可。

@RestController
public class StockController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @RequestMapping("/distributed-lock/substract-stock")
    public String subtractStock() {
        // 分布式锁key定义
        String redisLock = "distributed-lock";
        // 设值一个唯一标识,保障改线程仅能释放自己加的锁,不能释放别的线程的锁
        UUID clientId = UUID.randomUUID();
        String stockKey = "stock";
        try {
            // 相当于执行 setnx distributed-lock lock
            Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(redisLock, clientId.toString(), 30, TimeUnit.MILLISECONDS);
            // 设值失败,相当于没有得到锁,通过自旋方式尝试获得锁
            if (!result) {
                // 如果没有抢到锁,返回一个错误码,让前台做友好提示
                return "error";
            }
            // 减库存
            int stock = Integer.parseInt(Objects.requireNonNull(stringRedisTemplate.opsForValue().get(stockKey)));
            if (stock > 0) {
                stock = stock - 1;
                stringRedisTemplate.opsForValue().set(stockKey, stock + "");
                System.out.println("减库存成功,当前库存:" + stock);
            } else {
                System.out.println("库存不足");
            }
            return "succees";
        } finally {
            // 仅加锁的线程,能够释放该锁
            if (clientId.toString().equals(stringRedisTemplate.opsForValue().get(redisLock))) {
                // 放在finally中执行,保障异常场景下,锁能够得到释放
                stringRedisTemplate.delete(redisLock);
            }
        }
    }
}

想想上述代码是否还有问题？

问题：

假如线程A获得锁，30s没有把业务完成，比如还未获取库存，锁过期了，那么线程B获取锁，继续减库存，由于线程A业务还没完成，所以库存还未减，那么此时相当于两个线程同时去执行减库存了，也会出现超卖，不过概率很小。

解决：

Redisson

3.2 解决方案二：Redisson
  1. 添加依赖
<!-- springboot整合redisson -->
<dependency>
	<groupId>org.redisson</groupId>
	<artifactId>redisson-spring-boot-starter</artifactId>
	<version>3.16.0</version>
</dependency>
  1. 注入Redisson对象，定义Redisson Bean
@Configuration
public class ReddsionConfig {

    /**
     * 配置Redisson,来获取到redisLock
     *
     * @return Redisson
     */
    @Bean
    public Redisson redisson() {
        // Redisson为单机模式
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.216.129:6379").setDatabase(0);
        return (Redisson) Redisson.create(config);
    }
}
  1. 业务代码使用Redisson加锁、解锁实现分布式锁
@RestController
public class StockController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private Redisson redisson;

    @RequestMapping("/distributed-lock/substract-stock")
    public String subtractStock() {
        // 分布式锁key定义
        String redisLock = "distributed-lock";
        // 获取分布式锁,注意,此处默认过期时间是30s,由于没有显示定义过期时间,所以会默认给key续命
        RLock redissonLock = redisson.getLock(redisLock);
        try {
            // 加锁
            redissonLock.lock();
            String stockKey = "stock";
            // 减库存
            int stock = Integer.parseInt(Objects.requireNonNull(stringRedisTemplate.opsForValue().get(stockKey)));
            if (stock > 0) {
                stock = stock - 1;
                stringRedisTemplate.opsForValue().set(stockKey, stock + "");
                System.out.println("减库存成功,当前库存:" + stock);
            } else {
                System.out.println("库存不足");
            }
            return "succees";
        } finally {
            // 解锁
            redissonLock.unlock();
        }
    }
}
  1. 压测结果（无超卖）

请添加图片描述

请添加图片描述

注意点：

  1. RLock redissonLock = redisson.getLock(redisLock);

不显示给定key默认过期时间，Ression底层会给定30s过期时间，并且每隔30*1/3=10s，发现业务仍为执行完成，会继续续命到30s。

  1. redissonLock.lock(30, TimeUnit.MILLISECONDS);

显示给定超时时间，实际就是key过期时间，如果到了key过期时间，业务仍为执行完成，可能被别的线程解锁，导致报错，报错信息：java.lang.IllegalMonitorStateException: attempt to unlock lock, not locked by current thread by node id

Redisson底层原理图：

请添加图片描述

想想上述方案是否还有问题？

如果Redis搭哨兵集群方式，如果某个线程使用Ression加锁成功，突然Redis主节点宕机了，该锁还未来得及释放，那么Redis从节点此时选举为主节点，其Redis中的数据，相比主节点有缺失，可能之前锁信息丢失，导致别的线程又能获取到锁，造成分布式锁失效。

解决办法：

可以使用Zookeeper集群方式代替Redis方式，不过性能大大降低，所以需要在性能和高可用方面做取舍。

猛男走天下
关注
专栏目录
注解的方式优雅实现Ression分布式锁
m0_71777195的博客
03-28 1383
日常开发中，难免遇到一些并发的场景，为了保证接口执行的一致性，通常采用加锁的方式，因为服务是分布式部署模式，本地锁Reentrantlock和Synchnorized这些就先放到一边了，Redis的setnx锁存在无法抱保证原子性的问题就暂时搁且到一边，直接上大招Ression也是我最近开发项目中基本都在用的缓存，并且也都是用它的分布式锁机制。关于Ression的一些基本概念，本章就不做太详细的说明了，有兴趣的小伙伴可以自己去了解下，主要说下加锁的常规使用，Ression分布式锁是基于Redis的Rlock
Spring cloud Redisson实现分布式锁
u012255561的博客
09-23 419
Java之——redis并发读写锁，使用Redisson实现分布式锁 转载请注明出处：http://blog.csdn.net/l1028386804/article/details/73523810 1.可重入锁（Reentrant Lock） Redisson的分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口，同时还支持自动过期解锁。 public void testReentrantLock(RedissonClient redisson)
Redisson实现分布式锁从入门到应用
Javaer
10-12 1068
随着技术快速发展，数据规模增大，分布式系统越来越普及，一个应用往往会部署在多台机器上（多节点），在有些场景中，为了保证数据不重复，要求在同一时刻，同一任务只在一个节点上运行，即保证某一方法同一时刻只能被一个线程执行。白话讲分布式锁：所有请求的线程都去同一个地方占坑，如果有坑位，就执行业务逻辑，没有坑位，就需要其他线程释放坑位。这个坑位是所有线程可见的，可以把这个坑位放到 Redis 缓存或者数据库。
Redisson实现分布式锁原理
程序猿进阶
12-09 2291
Redisson实现分布式锁原理 一、高效分布式锁 当我们在设计分布式锁的时候，我们应该考虑分布式锁至少要满足的一些条件，同时考虑如何高效的设计分布式锁，这里我认为以下几点是必须要考虑的。 1、互斥 在分布式高并发的条件下，我们最需要保证，同一时刻只能有一个线程获得锁，这是最基本的一点。 2、防止死锁 在分布式高并发的条件下，比如有个线程获得锁的同时，还没有来得及去释放锁，就因为系统故障或者其它原因使它无法执行释放锁的命令,导致其它线程都无法获得锁，造成死锁。所以分布式非常有必要设置锁的有效时间，确保系统
redisson中的分布式锁解读
一个菜鸡的博客
05-10 1698
Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅 提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。
C#实操控制并发之Lock和Redis分布式锁
01-21
本文将深入探讨C#中如何使用Lock和Redis分布式锁来解决并发问题，以秒杀系统为例进行阐述。 首先，让我们理解什么是并发控制。并发控制是指在多线程环境下确保数据的一致性和完整性，防止多个线程同时访问同一资源...
Java Redis分布式锁的正确实现方式详解
08-25
Java Redis分布式锁的正确实现方式详解 Java Redis分布式锁是指使用Redis实现的分布式锁机制，旨在解决分布式系统中的并发问题。分布式锁有三种实现方式：数据库乐观锁、基于Redis的分布式锁和基于ZooKeeper的...
浅析Redis分布式锁
12-16
前期考虑的方案有采用ZooKeeper分布式任务,Quartz分布式任务调度,但是由于Zookeeper需要增加额外组件,Quartz需要增加表,并且项目中现在已经有Redis这一组件存在,所以考虑采用Redis分布式锁的情况来完成分布式任务...
Redis分布式锁的实现方式(redis面试题)
09-08
以下我们将详细讨论Redis分布式锁的正确实现方式以及常见的错误实践。 正确实现Redis分布式锁需要考虑以下几个关键点： 1. **互斥性**：同一时刻，只有一个客户端能够持有锁。Redis提供了`SETNX`（Set if Not ...
Redis分布式锁实现方式及超时问题解决
08-19
Redis分布式锁实现方式及超时问题解决 本文主要介绍了Redis分布式锁实现方式及超时问题解决，通过详细的示例代码和实现原理，帮助读者理解分布式锁的应用场景和实现方式，并解决分布式锁常见的问题。 一、分布式锁...
分布式锁 — Redisson 全面解析
weixin_44421461的博客
08-30 1327
????这是一个或许对你有用的社群????一对一交流/面试小册/简历优化/求职解惑，欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料：《项目实战（视频）》：从书中学，往事中“练”《互联网高频面试题》：面朝简历学习，春暖花开《架构 x 系统设计》：摧枯拉朽，掌控面试高频场景题《精进 Java 学习指南》：系统学习，互联网主流技术栈《必读 Java 源码专栏》：知其然，知其所以然????这是一个或许...
分布式锁Redisson详解（重点）
Java后端技术栈
12-25 5598
一、为什么需要分布式锁？ 在单体web应用的时候，如果多个线程要访问共享资源的时候，我们通常线程间加锁的机制，在某一个时刻，只有一个线程可以对这个资源进行操作，其他线程需要等待锁的释放，Java中也有一些处理锁的机制，比如synchronized。 而到了分布式的环境中，当某个资源可以被多个系统访问使用到的时候，为了保证大家访问这个数据是一致性的，那么就要求再同一个时刻，只能被一个系统使用，这时候线程之间的锁机制就无法起到作用了，因为分布式环境中，系统是会部署到不同的机器上面的，那么就需要【
Redis分布式锁—Redisson+RLock可重入锁实现篇
热门推荐
niceyoo的博客
10-28 1万+
前言 平时的工作中，由于生产环境中的项目是需要部署在多台服务器中的，所以经常会面临解决分布式场景下数据一致性的问题，那么就需要引入分布式锁来解决这一问题。 针对分布式锁的实现，目前比较常用的就如下几种方案： 基于数据库实现分布式锁 基于 Redis 实现分布式锁 【本文】 基于 Zookeeper 实现分布式锁 接下来这个系列文章会跟大家一块探讨这三种方案，本篇为 Redis 实现分布式锁篇。 Redis分布式环境搭建推荐：基于Docker的Redis集群搭建 Redis分布式锁一览 说到 Red
最强分布式工具Redisson：分布式锁
xc2011的博客
10-20 2909
redis 分布式锁 Redisson
Redisson分布式锁设计方案
杨杨杨~~的博客
06-04 393
文章目录前言20分钟带你熟悉Redisson分布式锁设计方案01重温分布式锁01::01 分布式锁的设计的几点要求01::02 分布式锁要如何理解?02 Redisson分布式锁设计的优点02::01 Redis分布式锁设计的不足03 Redisson分布式锁的功能特性04 Redisson分布式锁(可重入锁)实战04::01 Redisson分布式锁(可重入锁)一次性锁实战04::02 Redisson分布式锁(可重入锁)可重入锁实战 前言   如果您觉得有用的话，记得给博主点个赞，评论，收藏一键三连啊，
Redisson分布式锁
ronshi的博客
08-18 1008
Redisson分布式锁
Redis实战之搞懂Redisson分布式锁机制
最新发布
以梦为马
01-30 968
Redisson是什么？以下是官网的简介，相信各位彦祖们都能看懂，就不翻译了。线程安全的实现；支持多种Redis种模式，集群模式、哨兵模式、主从模式、单机模式等；支持主动重连、失败自动重试；丰富的数据类型：Object, Binary stream, BitSet, AtomicLong, Bloom filter, Map, Set, List, SortedSet, Queue, Deque等；
分布式锁总结
zbajie001的博客
04-11 470
以下内容主要是结合了好些帖子的总结。 ### 什么是锁？ 在单进程的系统中，当存在多个线程可以同时改变某个变量（可变共享变量）时，就需要对变量或代码块做同步，使其在修改这种变量时能够线性执行消除并发修改变量。 而同步的本质是通过锁来实现的。为了实现多个线程在一个时刻同一个代码块只能有一个线程可执行，那么需要在某个地方做个标记，这个标记必须每个线程都能看到，当标记不存在时可以设置该标记，其余后...
分布式锁Redis以及Ression分析
qq_33531432的博客
10-14 6134
参考博文： https://crazyfzw.github.io/2019/04/15/distributed-locks-with-redis/ http://wuwenliang.net/2019/07/23/%E5%86%8D%E8%B0%88%E5%88%86%E5%B8%83%E5%BC%8F%E9%94%81%E4%B9%8B%E5%89%96%E6%9E%90Redis%E5%AE%...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值