Redis的事务

Redis的事务

Redis的事务

1、是什么

可以一次执行多个命令,本质是一组命令的集合。一个事务中的所有命令都会序列化,按顺序地串行化执行而不会被其它命令插入,不许加塞。

2、能干什么

一个队列中,一次性、顺序性、排他性的执行命令。

3、使用

常用命令

(1)

case1:正常执行–multi

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
127.0.0.1:6379> FLUSHALL
OK
127.0.0.1:6379> keys *
(empty list or set)
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> get k2
QUEUED
127.0.0.1:6379> EXEC
1) OK
2) OK
3) OK
4) "v2"

case2:放弃事务–discard

1
2
3
4
5
6
7
8
9
10
11
12
13
127.0.0.1:6379> get k1
"v1"
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set k1 11
QUEUED
127.0.0.1:6379> set k2 22
QUEUED
127.0.0.1:6379> DISCARD
OK
127.0.0.1:6379> get k1
"v1"
127.0.0.1:6379>

case3:全体连坐

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
127.0.0.1:6379> get k1
"v1"
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set k1 111
QUEUED
127.0.0.1:6379> set k2 222
QUEUED
127.0.0.1:6379> set k3 333
QUEUED
127.0.0.1:6379> getset k1
(error) ERR wrong number of arguments for 'getset' command
127.0.0.1:6379> set k4 444
QUEUED
127.0.0.1:6379> EXEC
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get k1
"v1"
127.0.0.1:6379>

case4:冤头债主

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
127.0.0.1:6379> keys *
1) "k1"
2) "k3"
3) "k2"
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> incr k1
QUEUED
127.0.0.1:6379> set k2 22
QUEUED
127.0.0.1:6379> set k3 33
QUEUED
127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379> get k4
QUEUED
127.0.0.1:6379> EXEC
1) (error) ERR value is not an integer or out of range
2) OK
3) OK
4) OK
5) "v4"
127.0.0.1:6379> get k4
"v4"

与case3的区别在于,case在加入队列时就出错,所有全部执行失败,case4是在执行过程中出错,但加入队列时并没有出错,所以出错的执行不成功

case5: watch监控

悲观锁/乐观锁/CAS(Check And Set):
悲观锁:

悲观锁(Pessimistic Lock), 顾名思义,就是很悲观,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁;

乐观锁:

乐观锁(Optimistic Lock), 顾名思义,就是很乐观,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号等机制。乐观锁适用于多读的应用类型,这样可以提高吞吐量,乐观锁策略:提交版本必须大于记录当前版本才能执行更新

初始化信用卡可用余额和欠额
无加塞篡改,先监控再开启multi,保证两笔金额变动在同一个事务内
有加塞篡改:监控了key,如果key被修改了,后面一个事务的执行失效
unwatch:一旦执行了exec之前加的监控锁都会被取消掉了

1
2
3
4
5
6
7
8
9
10
11
127.0.0.1:6379> WATCH balance
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> DECRBY balance 20
QUEUED
127.0.0.1:6379> INCRBY debt 20
QUEUED
127.0.0.1:6379> EXEC
1) (integer) 80
2) (integer) 20

阶段:

开启:

以MULTI开始一个事务

入队:

将多个命令入队到事务中,接到这些命令并不会立即执行,而是放到等待执行的事务队列里面
执行:由EXEC命令触发事务

3个特性

单独的隔离操作:

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

没有隔离级别的概念:

队列中的命令没有提交之前都不会实际的被执行,因为事务提交前任何指令都不会被实际执行,也就不存在”事务内的查询要看到事务里的更新,在事务外查询不能看到”这个让人万分头痛的问题

不保证原子性:

redis同一个事务中如果有一条命令执行失败,其后的命令仍然会被执行,没有回滚

小结:

1、watch指令,类似乐观锁,事务提交时,如果Key的值已被别的客户端改变,比如:某个list已被别的客户端push\pop过了,整个事务队列都不会执行。

2、watch命令在执行事务之前监控多个keys,倘若在watch之后有任何Key的值发生了变化,exec命令执行的事务都将被放弃,同时返回Nullmuti-bulk应答以通知调用者事务执行失败。
1
2


文章目录
  1. 1. Redis的事务
    1. 1.1. 1、是什么
    2. 1.2. 2、能干什么
    3. 1.3. 3、使用
      1. 1.3.1. 常用命令
        1. 1.3.1.1. case1:正常执行–multi
        2. 1.3.1.2. case2:放弃事务–discard
        3. 1.3.1.3. case3:全体连坐
        4. 1.3.1.4. case4:冤头债主
        5. 1.3.1.5. case5: watch监控
          1. 1.3.1.5.1. 悲观锁/乐观锁/CAS(Check And Set):
            1. 1.3.1.5.1.1. 悲观锁:
            2. 1.3.1.5.1.2. 乐观锁:
    4. 1.4. 阶段:
      1. 1.4.1. 开启:
      2. 1.4.2. 入队:
    5. 1.5. 3个特性
      1. 1.5.1. 单独的隔离操作:
      2. 1.5.2. 没有隔离级别的概念:
      3. 1.5.3. 不保证原子性:
    6. 1.6. 小结: