Redis学习记录------Redis6的事务操作（九）

Love The Way You Lie 2024-04-08 13:08 119阅读 0赞

## Redis学习记录------Redis6的事务操作（九） ##

Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化，按顺序地执行。事务在执行过程中，不会被其他客户端发送来的命令请求所打断。  
Redis事务的主要作用就是**串联多个命令**防止别的命令插队。

### Multi、Exec、discard ###

从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，Redis会将之前的命令队列中的命令依次执行。  
组队的过程中可以通过discard来放弃组队。  
Multi：组队阶段（开启事务），Exec执行阶段（事务执行）。

multi  //返回OK
    set k1 v1 //返回QUEUED
    set k2 v2  //返回QUEUED
    exec //返回OK OK，两个OK
    //或者放弃组队
    discard //返回ok

### 事务的错误处理 ###

**注意：在Multi过程中，一个命令失败了，其他命令都会失败。在Exec过程中，一个命令失败了，其他命令还会成功执行！**  
组队时有命令错误，执行时整个都不会执行。

multi  //返回OK
    set k1 v1 //返回QUEUED
    incr k1   //此时命令是有问题的，v1不能加1，但还返回QUEUED，
    set k3 v3 //返回QUEUED
    exec //返回OK、error、OK，此时只有第二个命令执行失败，第一个和第三个命令成功执行

类似编译器，运行期。

### 事务冲突（悲观锁和乐观锁） ###

案例：三个人共用一个账户100元，此时同时买东西，一个人消费80、一个消费50、一个消费10.  
**悲观锁** ： 每次去拿数据的时候都人为别人会修改，所以每次拿数据时候都会上锁，这样别人每次拿数据就会block直到它拿到锁，**传统的关系型数据库里边就用到了很多这种锁机制**，比如**行锁**、**表锁**等， **读锁**、**写锁**等，都是在操作之前就先上锁。  
**乐观锁**：每次拿数据的时候都认为别人不会修改，所以不会上锁，但是更新时候会判断一下，在此期间别人有没有更新这个数据，可以使用版本号机制，通过对比版本号，判断是否更新。**乐观锁适用于多读的应用类型，这样可以提高吞吐量，Redis就是利用这种check-and-set机制实现事务的。**

### 演示乐观锁和事务特性 ###

WATCH key \[key…\]  
在执行multi之前，先执行watch key1 \[key2\]，可以监视一个（或多个）key，**如果在事务执行之前这个（或这些）key被其他命令所改动，那么事务将会被打断**。  
第一个终端

set k1 100
    watch k1
    multi
    incrby k1 10
    exec //返回110

第二个终端

watch k1
    multi
    incrby k1 10
    exec //返回nil，即失败

unwatch 取消WATCH命令对所有key的监视。  
如果在执行watch命令之后，exec命令或者discard命令先被执行了的话，就不需要再执行unwatch命令。

### Redis事务三特性 ###

#### 单独的隔离操作 ####

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

#### 没有隔离级别的概念 ####

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

#### 不保证原子性 ####

事务中如果有一条命令执行失败，其他命令任然会被执行，没有回滚。

### 秒杀案例 ###

#### 无并发版本： ####

//秒杀案例
        public static boolean deSecKill(String uid,String pid){
        
            //1.对uid和pid进行判空
            if (uid == null || pid == null){
        
                return false;
            }
            //2.连接redis
            Jedis jedis = new Jedis("192.168.44.168",6379);
            //3.拼接key
            //3.1 库存key
            String kcKey = "sk:"+pid+":qt";
            //3.2 秒杀成功用户key
            String uidKey = "sk:"+pid+":user";
            //4 获取库存，如果获取库存等于null，秒杀没有开始
            String kc = jedis.get(kcKey);
            if (kc == null){
        
                System.out.println("秒杀还未开始");
                jedis.close();
                return false;
            }
            //5 判断是否重复秒杀操作
            Boolean sismember = jedis.sismember(uidKey, uid);
            if (sismember){
        
                System.out.println("已成功秒杀，勿重复操作");
                jedis.close();
                return false;
            }
            //6判断如果商品数量，库存数量小于1，秒杀结束
            int i = Integer.parseInt(kc);
            if (i<1){
        
                System.out.println("秒杀结束");
                jedis.close();
                return false;
            }
            //7秒杀过程
            //7.1库存-1
            jedis.decr(kcKey);
            //7.2把秒杀成功用户添加到成功清单中
            jedis.sadd(uidKey,uid);
            System.out.println("秒杀成功");
            jedis.close();
            return true;
        }

并发情况下会有两个问题：1.连接超时问题，2.超卖问题

#### 并发版本 ####

安装模拟工具  
yum install httpd-tools  
首先自定义JedisPool ，通过连接池解决超时问题。

package com.jedis;
    
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    public class JedisPoolUtile {
        
    
        private static JedisPool jedisPool = null;
    
        private JedisPoolUtile(){
        
    
        }
    
        public static JedisPool getJedisPoolInstance(){
        
            if (null == jedisPool){
        
                synchronized (JedisPoolUtile.class){
        
                    if (null == jedisPool){
        
                        JedisPoolConfig poolConfig = new JedisPoolConfig();
                        poolConfig.setMaxTotal(200);
                        poolConfig.setMaxIdle(32);
                        poolConfig.setMaxWaitMillis(100*1000);
                        poolConfig.setBlockWhenExhausted(true);
                        poolConfig.setTestOnBorrow(true);
    
                        jedisPool = new JedisPool(poolConfig,"192.168.44.168",6379,6000);
    
                    }
                }
            }
            return jedisPool;
        }
    }

修改后：增加事务以及使用连接池

//秒杀案例
        public static boolean deSecKill(String uid,String pid){
        
            //1.对uid和pid进行判空
            if (uid == null || pid == null){
        
                return false;
            }
            //2.连接redis
            JedisPool jedisPoolInstance = JedisPoolUtile.getJedisPoolInstance();
            Jedis jedis = jedisPoolInstance.getResource();
            //3.拼接key
            //3.1 库存key
            String kcKey = "sk:"+pid+":qt";
            //3.2 秒杀成功用户key
            String uidKey = "sk:"+pid+":user";
            //监视库存
            jedis.watch(kcKey);
            //4 获取库存，如果获取库存等于null，秒杀没有开始
            String kc = jedis.get(kcKey);
            if (kc == null){
        
                System.out.println("秒杀还未开始");
                jedis.close();
                return false;
            }
            //5 判断是否重复秒杀操作
            Boolean sismember = jedis.sismember(uidKey, uid);
            if (sismember){
        
                System.out.println("已成功秒杀，勿重复操作");
                jedis.close();
                return false;
            }
            //6判断如果商品数量，库存数量小于1，秒杀结束
            int i = Integer.parseInt(kc);
            if (i<1){
        
                System.out.println("秒杀结束");
                jedis.close();
                return false;
            }
            //7秒杀过程
            //使用事务
            Transaction multi = jedis.multi();
            //组队操作
            multi.decr(kcKey);
            multi.sadd(uidKey,uid);
            //执行操作
            List<Object> exec = multi.exec();
            if (exec == null || exec.size()  == 0){
        
                System.out.println("秒杀失败");
                jedis.close();
                return false;
            }
            //7.1库存-1
    //        jedis.decr(kcKey);
            //7.2把秒杀成功用户添加到成功清单中
    //        jedis.sadd(uidKey,uid);
            System.out.println("秒杀成功");
            jedis.close();
            return true;
        }

但是当数目够大，并发够多时，还是会出现

#### 乐观锁造成库存遗留的问题 ####

造成的原因：假如2000个人抢500个，假如第一个人抢到了，修改版本号，剩下1999人看到版本号被修改后就放弃操作了。  
可以通过**lua脚本**进行操作，但是Redis2.6以上地版本才支持lua脚本。变相变成悲观锁。