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

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
1
2
3
4
5
6

事务的错误处理

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

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

类似编译器，运行期。

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

案例：三个人共用一个账户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
1
2
3
4
5

第二个终端

watch k1
multi
incrby k1 10
exec //返回nil，即失败
1
2
3
4

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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

并发情况下会有两个问题：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;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

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

  //秒杀案例
    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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

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

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

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