Redis基础教程（三）Redis的事务

最新推荐文章于 2023-08-08 08:00:00 发布

长安不及十里

最新推荐文章于 2023-08-08 08:00:00 发布

阅读量296

点赞数

分类专栏： # Redis 文章标签： redis 队列数据库 java 分布式

小林

本文链接：https://blog.csdn.net/weixin_44451022/article/details/116502191

版权

Redis 专栏收录该内容

7 篇文章 1 订阅

订阅专栏

本文详细介绍了SpringBoot如何整合Redis，包括引入依赖和配置修改。接着讲解了Redis的事务特性，如一次性、顺序性和排他性，以及在不同异常情况下事务的执行情况。还探讨了乐观锁与悲观锁的概念及其在Redis中的应用。同时，文章通过示例展示了如何利用Redis实现秒杀业务，包括序列化配置和关键代码实现。最后，提到了Redis事务的三个特性：单独的隔离操作、没有隔离级别和不保证原子性。

摘要由CSDN通过智能技术生成

文章目录

- 三事务

三事务

3.1 SpringBoot整合Redis

依赖导入

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

配置修改

spring.redis.host=自己的服务器地址
spring.redis.port=6379
spring.redis.lettuce.pool.max-active=8
server.port=8080

启动，如何没有报错，就整合成功

3.2 Redis的事务

Redis 事务本质：一组命令的集合！一个事务中的所有命令都会被序列化，在事务执行过程的中，会按照顺序执行！一次性、顺序性、排他性！执行一些列的命令！

Redis事务没有没有隔离级别的概念！所有的命令在事务中，并没有直接被执行！只有发起执行命令的时候才会执行！Exec Redis单条命令式保存原子性的，但是事务不保证原子性！ redis的事务：开启事务（multi）命令入队（…）执行事务（exec）

正常执行事务！

127.0.0.1:6379> multi # 开启事务
OK
# 命令入队
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> get k2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> exec # 执行事务
1) OK
2) OK
3) "v2"
4) OK

放弃事务！

127.0.0.1:6379> multi # 开启事务
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379> DISCARD # 取消事务
OK
127.0.0.1:6379> get k4 # 事务队列中命令都不会被执行！
(nil

编译型异常（代码有问题！命令有错！），事务中所有的命令都不会被执行！

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> getset k3 # 错误的命令
(error) ERR wrong number of arguments for 'getset' command
127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379> set k5 v5
QUEUED
127.0.0.1:6379> exec # 执行事务报错！
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get k5 # 所有的命令都不会被执行！
(nil)

运行时异常（1/0），如果事务队列中存在语法性，那么执行命令的时候，其他命令是可以正常执行的，错误命令抛出异常！

127.0.0.1:6379> set k1 "v1"
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> incr k1 # 会执行的时候失败！
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> get k3
QUEUED
127.0.0.1:6379> exec
1) (error) ERR value is not an integer or out of range # 虽然第一条命令报错了，但是
依旧正常执行成功了！
2) OK
3) OK
4) "v3"
127.0.0.1:6379> get k2
"v2"
127.0.0.1:6379> get k3
"v3"

3.3 乐观锁与悲观锁

悲观锁(Pessimistic Lock)：顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。
乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量。Redis就是利用这种check-and-set机制实现事务的。
WATCH key [key ...]：果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。
unwatch：取消 WATCH 命令对所有 key 的监视

127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 0
OK
127.0.0.1:6379> watch money # 监视 money 对象
OK
127.0.0.1:6379> multi # 事务正常结束，数据期间没有发生变动，这个时候就正常执行成功！
OK
127.0.0.1:6379> DECRBY money 20
QUEUED
127.0.0.1:6379> INCRBY out 20
QUEUED
127.0.0.1:6379> exec
1) (integer) 80
2) (integer) 20


127.0.0.1:6379> watch money # 监视 money
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> DECRBY money 10
QUEUED
127.0.0.1:6379> INCRBY out 10
QUEUED
127.0.0.1:6379> exec # 执行之前，另外一个线程，修改了我们的值，这个时候，就会导致事务执行失
败！
(nil)
如果修改失败，获取最新的值就好,先解锁（unwatch），在监控(watch)

3.4 Redis事务三特性

单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断
没有隔离级别的概念：队列中的命令没有提交之前都不会实际被执行，因为事务提交前任何指令都不会被实际执行
不保证原子性：事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚

3.5 Redis 实现秒杀业务

序列化配置

@Configuration
public class RedisConfig {
    // 这是我给大家写好的一个固定模板，大家在企业中，拿去就可以直接使用！
    // 自己定义了一个 RedisTemplate
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        // 我们为了自己开发方便，一般直接使用 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        // Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

}

参考代码

/**
 * @author shu
 * @date 2021/4/28
 * @description 秒杀业务
 */
@Service
public class Seckill {

    @Autowired
    RedisTemplate<String, Object> redisTemplate;


    public Boolean SecKillService(String uid,String prodid){
        // uid和prodid非空判断
        if(uid == null || prodid == null) {
            return false;
        }
        // 库存key
        String kcKey = "sk:"+prodid+":qt";
        //秒杀成功用户key
        String userKey = "sk:"+prodid+":user";

        //监视库存
        redisTemplate.watch(kcKey);

        //获取库存，如果库存null，秒杀还没有开始
        Integer kc = (Integer) redisTemplate.opsForValue().get(kcKey);
        if(kc == null) {
            System.out.println("秒杀还没有开始，请等待");
            return false;
        }

        //判断用户是否重复秒杀操作
        System.out.println(redisTemplate.opsForSet().isMember(userKey, uid));
        if(redisTemplate.opsForSet().isMember(userKey, uid)) {
            System.out.println("已经秒杀成功了，不能重复秒杀");
            return false;
        }

        //判断如果商品数量，库存数量小于1，秒杀结束
        if(kc<=0) {
            System.out.println("秒杀已经结束了");
            return false;
        }
        //秒杀
        SessionCallback<Boolean> sessionCallback = new SessionCallback<Boolean>() {
            List<String> exec = null;
            @Override
            @SuppressWarnings("unchecked")
            public Boolean execute(RedisOperations operations) throws DataAccessException {
                operations.multi();
                redisTemplate.opsForValue().decrement(kcKey);
                redisTemplate.opsForSet().add(userKey,uid);
                exec = operations.exec();
                if(exec.size() > 0) {
                    System.out.println("秒杀成功了");
                    return true;
                }
                System.out.println("秒杀失败了");
                return false;
            }
        };
        return redisTemplate.execute(sessionCallback);

    }

}

测试工具模拟线程

在这里插入图片描述

长安不及十里

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Redis基础教程（三）Redis的事务

文章目录三事务3.1 SpringBoot整合Redis3.2 Redis的事务3.3 乐观锁与悲观锁3.4 Redis事务三特性3.5 Redis 实现秒杀业务三事务3.1 SpringBoot整合Redis依赖导入<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-da
复制链接

扫一扫