[学习记录] Redis 5. 事务和锁机制，秒杀案例 Demo

最新推荐文章于 2024-07-26 17:37:22 发布
最新推荐文章于 2024-07-26 17:37:22 发布
阅读量411 收藏 1
点赞数
分类专栏： 数据库 文章标签： redis 学习 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39906884/article/details/127016435
版权

Redis 5. 事务和锁机制，秒杀案例 Demo

参考课程：https://www.bilibili.com/video/BV1Rv41177Af

参考书：https://blog.csdn.net/liu8490631/article/details/124290851

1. Redis 事务定义

Redis 事务是一个单独的隔离操作，事务中的所有命令都会序列化，按顺序地执行。

事务在执行过程中，不会被其他地客户端发送来地命令请求所打断。

Redis 事务地主要作用就是串联多个命令防止别地命令插队。

2. Multi，Exec，Discard

输入 Multi 后，输入的命令会依次进入命令队列，但不会执行，直到输入 Exec 后，Redis 会将之前的命令队列中的命令依次执行，discard 会抛弃命令队列中的命令。

类似于 MySQL 中 start transaction/begin 开启事务，commit 提交事务，rollback 回滚事务。

3. 事务错误处理

当 Redis 事务中有命令报错 ERROR，则该事务中的所有命令都不执行：
在这里插入图片描述

事务中没有错误，事务执行过程中出现错误，则报错的语句不执行，其他命令正常执行：
在这里插入图片描述

4. 事务冲突的问题

一般情况下，三个事务同时修改余额，可能会导致余额不够买一个商品但是买下来了的情况。这就是事务冲突。解决冲突的方法：

4.1 悲观锁（Pessimistic Lock）

每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞，直到它拿到锁。

  • 传统的关系型数据库里面就用到了很多这种锁机制，比如行锁，表锁，读锁，写锁等，都是在做操作之前先上锁。

  • 缺点：效率低

4.2 乐观锁（Optimistic Lock）

每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。

  • 乐观锁适用于多读的应用类型，这样可以提高吞吐量

  • Redis 采用的就是这种 check-and-set 机制实现事务的

  • 典型场景：抢票

4.3 WATCH key [key …]

在执行 MULTI 之前，先执行 watch key1 [key2 ...]，可以监视一个（或者多个）key，如果在事务执行之前这个或这些 key 被其他命令所改动，那么事务将被打断。

事务 1 和事务 2 同时 watch 一个 key，然后都 multi 开启事务：

  1. 事务 1 对 key 进行修改，exec，修改成功
  2. 事务 2 对 key 进行修改，exec，可以看到返回（nil），修改失败
  • unwatch 可以取消 key 的监视，若执行 watch 命令后又执行了 exec 或者 discard 的话，就不用执行 unwatch 了。

5. Redis 事务三特性

5.1 单独隔离性

  • 事务中的所有命令都会序列化，按照顺序执行。
  • 事务在执行过程中，不会被其他的客户端发送来的命令请求所打断。

5.2 没有隔离级别的概念

  • 队列中的命令没有提交之前都不会实际被执行，因为事务提交前任何指令都不会被实际执行。

5.3 不保证原子性

  • 事务执行过程中如果有一条命令执行失败，其后面的命令仍然会被执行，没有回滚
  • 若在队列中发生语法错误等则该事务中的所有元素都会被 discard

6. 秒杀案例 Demo

需求：

  • 商品库存：个数减少
  • 秒杀成功清单：加人

6.0 前情提要

SpringBoot 默认序列化方式可读性太差了：
在这里插入图片描述
换成 Jackson

@Configuration
public class RedisConfig {
    /**
     * 设置redis键值的序列化方式
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        /*
         * value值的序列化可采用如下几种方式
         * 1.默认采用JdkSerializationRedisSerializer 序列化后的长度最短，时间适中，但不是明文显示
         * 2.采用Jackson2JsonRedisSerializer 明文显示，序列化速度最快，长度适中，但会使存入redis中timestamp类型的数据以long类型存储
         * 3.采用GenericJackson2JsonRedisSerializer 明文显示，在redis中显示了@class字段保存有类型的包路径，反序列化更容易，但是序列化时间最长，长度最大，明文显示
         * 4.自定义FastJsonRedisSerializer实现RedisSerializer接口
         *
         * 这里使用Jackson2JsonRedisSerializer，并对日期类型做特别处理
         */
        Jackson2JsonRedisSerializer<Object> redisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        /*
         *  指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
         *  过期方法：om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
         */
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                ObjectMapper.DefaultTyping.NON_FINAL,
                JsonTypeInfo.As.WRAPPER_ARRAY);

        // 日期序列化处理
        om.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        om.registerModule(new Jdk8Module())
                .registerModule(new JavaTimeModule())
                .registerModule(new ParameterNamesModule());
        redisSerializer.setObjectMapper(om);

        // 设置值（value）的序列化采用Jackson2JsonRedisSerializer
        template.setValueSerializer(redisSerializer);
        template.setHashValueSerializer(redisSerializer);

        // 设置键（key）的序列化采用StringRedisSerializer
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());

        template.afterPropertiesSet();

        return template;
    }
}

字符串的 value 保存后是 "\"world\"" 的形式，数字类型默认为 Integer，即使字符串进去出来也是 Integer，小数默认就是 Double。

在这里插入图片描述

6.1 简单案例

package com.xz.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.web.bind.annotation.*;

import java.util.Set;

@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;
    
    @PostMapping("/test")
    public boolean test2 (String uid, String prodid) {
        ValueOperations opsString = redisTemplate.opsForValue();
        SetOperations opsSet = redisTemplate.opsForSet();

        // 判空
        if (uid == null || prodid == null) {
            return false;
        }

        // 拼接 key, 库存 key , 秒杀成功用户 key
        String kcKey = "sk:" + prodid + ":qt";
        String userKey = "sk:" + prodid + ":user";

        // 获取库存, 若库存为 null, 秒杀未开始
        Object kc = opsString.get(kcKey);

        if (kc == null) {
            System.out.println("秒杀活动未开始!");
            return false;
        }

        // 判断是否重复秒杀操作
        if (Boolean.TRUE.equals(opsSet.isMember(userKey, uid))) {
            System.out.println("已经参与秒杀, 不能重复参与!");
            return false;
        }

        // 判断如果商品数量 < 1, 秒杀结束
        if ((Integer)kc < 1) {
            System.out.println("秒杀已经结束!");
            return false;
        }

        // 秒杀过程  库存 -1, 秒杀成功的用户添加进清单
        opsString.decrement(kcKey);
        opsSet.add(userKey, uid);
        System.out.println("用户 " + uid + " 参与 " + prodid + " 的秒杀活动参与成功!");
        return true;
    }

6.3 JMeter 测试

在这里插入图片描述

在这里插入图片描述

Redis 设置 0101 号商品库存为 10：

SET sk:0101:qt 10

500 个线程，每个线程抢两次。

在这里插入图片描述
10 件商品卖出去了 200 件。
严重超卖！

6.4 超卖问题

下面这代码并没有完全解决超卖，还不知道啥原因，记录一下，往后学一学，能解决了再来改！我设置一千个线程都超了！

找到原因了找到原因了，监视库存应该放在所有对 Redis 访问或者修改操作之前！

错误代码，监视库存只放在 Redis 写操作之前：

@PostMapping("/test")
    public boolean test2 (String uid, String prodid) {
        // 判空
        if (uid == null || prodid == null) {
            return false;
        }

        // 拼接 key, 库存 key , 秒杀成功用户 key
        String kcKey = "sk:" + prodid + ":qt";
        String userKey = "sk:" + prodid + ":user";


        // 获取库存, 若库存为 null, 秒杀未开始
        Object kc = redisTemplate.opsForValue().get(kcKey);

        if (kc == null) {
            System.out.println("秒杀活动未开始!");
            return false;
        }

        // 判断是否重复秒杀操作
        if (Boolean.TRUE.equals(redisTemplate.opsForSet().isMember(userKey, uid))) {
            System.out.println("已经参与秒杀, 不能重复参与!");
            return false;
        }

        // 判断如果商品数量 < 1, 秒杀结束
        if ((Integer)kc < 1) {
            System.out.println("秒杀已经结束!");
            return false;
        }

        /*
        * 事务
        * */

        SessionCallback sessionCallback = new SessionCallback() {
            @Override
            public Object execute(RedisOperations operations) throws DataAccessException {
                // 监视库存
                operations.watch(kcKey);
                operations.multi();
                // 秒杀过程  库存 -1, 秒杀成功的用户添加进清单
                redisTemplate.opsForValue().decrement(kcKey);
                redisTemplate.opsForSet().add(userKey, uid);
                return operations.exec();
            }
        };

        List result = (List) redisTemplate.execute(sessionCallback);

        if (result == null || result.size() == 0) {
            System.out.println("秒杀失败了......");
            return false;
        }

        System.out.println("用户 " + uid + " 参与 " + prodid + " 的秒杀活动参与成功!");
        return true;
    }

在这里插入图片描述

正确代码，监视库存应该放在所有对 Redis 访问或者修改操作之前：

@PostMapping("/test")
    public boolean test2 (String uid, String prodid) {
        // 判空
        if (uid == null || prodid == null) {
            return false;
        }

        // 拼接 key, 库存 key , 秒杀成功用户 key
        String kcKey = "sk:" + prodid + ":qt";
        String userKey = "sk:" + prodid + ":user";


        /*
        * 事务
        * */
        SessionCallback sessionCallback = new SessionCallback() {
            @Override
            public Object execute(RedisOperations operations) throws DataAccessException {
                // 监视库存
                List<String> list = new ArrayList<>();
                list.add(kcKey);
                operations.watch(list);
                Object kc = redisTemplate.opsForValue().get(kcKey);

                // 获取库存, 若库存为 null, 秒杀未开始
                if (kc == null) {
                    System.out.println("秒杀活动未开始!");
                    return null;
                }

                // 判断是否重复秒杀操作
                if (Boolean.TRUE.equals(redisTemplate.opsForSet().isMember(userKey, uid))) {
                    System.out.println("已经参与秒杀, 不能重复参与!");
                    return null;
                }

                // 判断如果商品数量 < 1, 秒杀结束, (再次获取)
                if ((Integer) kc < 1) {
                    System.out.println("秒杀已经结束!");
                    return null;
                }

                operations.multi();
                // 秒杀过程  库存 -1, 秒杀成功的用户添加进清单
                redisTemplate.opsForValue().decrement(kcKey);
                redisTemplate.opsForSet().add(userKey, uid);
                return operations.exec();
            }
        };

        List result = (List) redisTemplate.execute(sessionCallback);

        if (result == null || result.size() == 0) {
            System.out.println("秒杀失败了......");
            return false;
        }

        System.out.println("用户 " + uid + " 参与 " + prodid + " 的秒杀活动参与成功!");
        return true;
    }

再次测试：
在这里插入图片描述

完美！

6.5 连接超时问题

Q：Redis 不是单线程吗？为什么还需要连接池？

A: https://blog.csdn.net/forBurnInG/article/details/103893680

Q：连接池最大连接数越大越好？

A：https://zhuanlan.zhihu.com/p/396034724

因为我用的 SpringDataRedis，RedisTemplate 默认用的就是连接池，所以不会遇到连接超时问题。

拿 Mysql 举个例子：

不用连接池：
在这里插入图片描述

使用连接池：

在这里插入图片描述

不适用连接池的步骤：

  1. 建立 TCP 连接
  2. 建立数据库连接
  3. 执行语句
  4. 断开数据库连接
  5. 断开 TCP 连接

连接池的作用：

  • 资源重用，节省每次连接服务带来的消耗
  • 更快的响应速度，直接利用了现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而缩减了系统整体响应时间。

6.6 （使用乐观锁）库存遗留问题

设置商品大一点，然后测试：

在这里插入图片描述

出现了库存遗留问题。

Lua 脚本解决该问题，我再学学，看看有没有其他方法，有的话我再来补充！
https://www.jianshu.com/p/a555facfd6c8

哇咔咔负负得正
关注
专栏目录
Redis API 必杀解读:引入RedisTemplate
向小凯同学学习
08-18 3万+
题记在工作和学习中啊，比如说JAVA开发，要使用Redis，首先要引入一个RedisTemplate类// // Source code recreated from a .class file by IntelliJ IDEA // (powered by Fernflower decompiler) //package org.springframework.data.redis.core;im
Redis-10-Redis的事务使用案例-秒杀
苍煜
03-05 572
文章目录1:简单版本使用redis控制秒杀2：使用乐观锁解决超卖问题3：使用redis连接池管理redis连接，设置超时时间4:使用lua脚本方法解决少买问题 1:简单版本使用redis控制秒杀 这是不考虑任何逻辑产生的一个秒杀demo，经过试验后发现问题，当并发情况下会产生超卖和连接超时问题 //秒杀过程 public static boolean doSecKill(String uid,String prodid) throws IOException { //1 uid和p
Redis实现乐观锁+秒杀场景demo
qq_53281187的博客
03-03 405
在Redis中，乐观锁通常是通过使用 WATCH、MULTI 和 EXEC 命令实现的。这种乐观锁机制允许客户端在执行事务期间监视一个或多个键，并且只有在事务执行期间没有其他客户端修改被监视的键时，才会执行事务。
Redis学习笔记（上）：常用数据类型，发布订阅，事务和锁机制，持久化，集群，雪崩，缓存击穿，分布式锁
RuanFun的博客
09-29 653
Redis学习笔记：常用数据类型，发布订阅，事务和锁机制，持久化，集群，雪崩，缓存击穿，分布式锁...
Redis_学习笔记（2024.04）
dameizizizi123的博客
04-02 633
技术的分类解决功能性的问题：Java、Jsp、RDBMS、Tomcat、HTML、Linux、JDBC、SVN解决扩展性的问题：Struts、Spring、SpringMVC、Hibernate、Mybatis解决性能的问题：NoSQL、Java线程、Hadoop、Nginx、MQ、ElasticSearchWeb1.0时代Web1.0的时代，数据访问量很有限，用一夫当关的高性能的单点服务器可以解决大部分问题。Web2.0时代。
redis分布式锁和简单秒杀限流的实现
csdncjh的博客
05-23 1207
分布式锁 看门狗防止死锁 redission实现 依赖 <!--整合redission框架start--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> &...
Redis 7.x 系列【31】LUA 脚本
最新发布
记录知识、锤炼自我
07-26 1159
Lua 语言是一种小巧的、高效的、可嵌入的脚本编程语言，由巴西里约热内卢天主教大学的一个研究小组于 1993 年开发。设计目的是为了通过灵活嵌入应用程序中，为应用程序提供灵活的扩展和定制功能。 Redis 2.6 版本开始支持用户在服务器上传和执行 Lua 脚本，从而实现复杂的操作逻辑。脚本在 Redis 中是以字符串的形式传递给服务器的，然后服务器会执行这些脚本并返回结果。脚本在 Redis 中由内置的执行引擎执行。目前，仅支持一个脚本引擎，即 Lua 5.1 解释器。
Redis（二十三）-秒杀案例之超卖和超时问题解决
码农飞哥
05-05 2914
本文详细介绍了如何解决秒杀案例中的超卖以及超时问题。
Redis | 22.Redis事务案例 - 秒杀
xyx-Eshang的博客
09-23 241
0.前言 24-尚硅谷-Redis6-事务和锁机制-秒杀案例-基本实现 1.商品秒杀 商家上架数量极少、价格极低的产品供用户抢购 可行性判断 商品库存 - 1 生成商品订单 2.代码实现 库存 - stock:FX627 : 50 50为库存数量 订单 - order:FX627 : 12 12为用户id package com.eshang.jedis.demo02.service; import com.eshang.
seckill-demo.zip
02-21
在本案例中，“seckill-demo.zip&rdquo;是一个包含抢购秒杀功能的源码实现，主要运用了Redis作为数据缓存来提高系统的性能和并发处理能力。以下将详细介绍这个系统的相关知识点： 1. **Redis**： Redis 是一个高性能的...
seckill_demo.zip
11-11
【标题】"seckill_demo....这个秒杀系统的实现，不仅展示了Java、SpringBoot、Redis和RabbitMQ的集成应用，还体现了微服务架构中的解耦、异步处理和高可用设计原则，是学习和实践高并发场景下服务设计的一个良好案例。
Redis框架从入门到学精（全）
热门推荐
码农研究僧的博客
07-02 2万+
目录前言1.NoSQL2.Redis2.1 软件安装数据类型 前言 解决功能新问题：JAVA jsp rdsms tomcat html linux jdbc svn 解决发展性问题：strtus spring springmvc hibernate mybatis 解决性能问题：NOSQL java 线程 hadoop nginx mq elasticsearch 1.NoSQL NoSQL特点 非关系型数据库，不依赖业务逻辑数据库存储，以简单key-value存储 适用于 ~高并发读写 ~海量数据读
java | (三十七)redis（2）事务
weixin_42953201的博客
11-19 1110
目录事务multi，exec，discard事务冲突，锁操作（乐观锁和悲观锁）案例：超卖Redis持久化RDBAOP主从复制 事务 multi，exec，discard redis事务是一个单独的隔离操作：事务中的所有命令都会序列化，按顺序地执行。事务在执行的过程中，不会被其它客户端发送来的命令请求所打断。Redis事务的主要作用就是串联多个命令防止别的命令插队 从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后Redis会将之前的命令队列中的命令依次执行。组队过程中
MOOC战德臣数据库课程自用笔记_1_数据库系统结构和数据模型概述
负负得正的博客
03-04 855
数据库系统的结构 从数据库应用开发人员角度，数据库系统通常采用三级模式结构，这是数据库系统内部的系统结构。 从数据库最终用户角度看，数据库系统的结构分为单用户结构，多用户结构，主从式结构，分布式结构，CS，BS/数据库服务器多层结构等。 概念辨析 模式 Schema 对数据库中数据所进行的一种结构性的描述，所观察到数据的结构信息 视图 View / 数据 Data 某一种表现形式下表现出来的数据库中的数据 三级模式结构 结构角度看是模式，数据角度看是视图 外模式/用户模式 —（外部）视图 局部层面，某一
MOOC战德臣数据库课程自用笔记_5_SQL复杂查询与视图
负负得正的博客
03-07 580
SQL复杂查询与视图 一. 子查询 出现在 Where 子句中的 Select 语句被称为子查询（subquery） 三种类型的子查询： (NOT) IN θ-Some/θ-ALL ，θ 为比较运算符 (NOT) EXISTS 1. (NOT) IN子查询 判断某一表达式的值是否存在于子查询的结果中 表达式 [not] in (子查询) 例子：列出张三，王三同学的所有信息 Select * From Student Where Sname in ("张三", "王三"); 2. θ some 子查
MOOC战德臣数据库课程自用笔记_2_关系模式
负负得正的博客
03-04 362
关系模式 一. 关系模式研究内容 一个关系就是一个Table 关系模型就是处理Table的，有三个部分： 描述DB各种数据的基本结构形式（Table/Relation） 描述Table与Table之间所可能发生的各种操作（关系运算） 描述这些操作所应该遵循的约束条件（完整性约束） 就是要学习：Table如何描述？有什么操作？结果是什么？有哪些约束等？ 二. 关系模型三个要素 基本结构：Relation/Table 基本操作：∪,−,×,δ,∏,π,∩,⋈,÷∪, -, ×, \delta, \prod
SQL 问题记录
负负得正的博客
09-04 355
SQL 问题记录。最后更新：2022.10.18
redis的事务和锁机制
10-13
Redis的事务和锁机制是两个不同的概念。 Redis的事务是通过MULTI、EXEC、DISCARD等命令实现的。在MULTI命令执行后，客户端可以将多个命令打包成一个事务，然后通过EXEC命令一次性执行。如果在事务执行期间出现错误...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

哇咔咔负负得正

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

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

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

打赏作者

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

抵扣说明：

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

余额充值