Ref: https://pdai.tech/md/db/nosql-redis/db-redis-x-trans.html

什么是 Redis 事务

Redis 事务的本质是一组命令的集合。事务支持一次执行多个命令，一个事务中所有命令都会被序列化。在事务执行过程，会按照顺序串行化执行队列中的命令，其他客户端提交的命令请求不会插入到事务执行命令序列中。
总结说：redis 事务就是一次性、顺序性、排他性的执行一个队列中的一系列命令。

Redis 事务相关命令和使用

MULTI 、 EXEC 、 DISCARD 和 WATCH 是 Redis 事务相关的命令。

  • MULTI ：开启事务，redis 会将后续的命令逐个放入队列中，然后使用 EXEC 命令来原子化执行这个命令系列。
  • EXEC：执行事务中的所有操作命令。
  • DISCARD：取消事务，放弃执行事务块中的所有命令。
  • WATCH：监视一个或多个 key, 如果事务在执行前，这个 key (或多个 key) 被其他命令修改，则事务被中断，不会执行事务中的任何命令。

  • UNWATCH：取消 WATCH 对所有 key 的监视。

    标准的事务执行

    给 k1、k2 分别赋值，在事务中修改 k1、k2，执行事务后，查看 k1、k2 值都被修改。

    1. 127.0.0.1:6379> set k1 v1
    2. OK
    3. 127.0.0.1:6379> set k2 v2
    4. OK
    5. 127.0.0.1:6379> MULTI
    6. OK
    7. 127.0.0.1:6379> set k1 11
    8. QUEUED
    9. 127.0.0.1:6379> set k2 22
    10. QUEUED
    11. 127.0.0.1:6379> EXEC
    12. 1) OK
    13. 2) OK
    14. 127.0.0.1:6379> get k1
    15. "11"
    16. 127.0.0.1:6379> get k2
    17. "22"
    18. 127.0.0.1:6379>

    事务取消

    1. 127.0.0.1:6379> MULTI
    2. OK
    3. 127.0.0.1:6379> set k1 33
    4. QUEUED
    5. 127.0.0.1:6379> set k2 34
    6. QUEUED
    7. 127.0.0.1:6379> DISCARD
    8. OK

    事务出现错误的处理

  • 语法错误（编译器错误）

在开启事务后，修改 k1 值为 11，k2 值为 22，但 k2 语法错误，最终导致事务提交失败，k1、k2 保留原值。

  1. 127.0.0.1:6379> set k1 v1
  2. OK
  3. 127.0.0.1:6379> set k2 v2
  4. OK
  5. 127.0.0.1:6379> MULTI
  6. OK
  7. 127.0.0.1:6379> set k1 11
  8. QUEUED
  9. 127.0.0.1:6379> sets k2 22
  10. (error) ERR unknown command `sets`, with args beginning with: `k2`, `22`, 
  11. 127.0.0.1:6379> exec
  12. (error) EXECABORT Transaction discarded because of previous errors.
  13. 127.0.0.1:6379> get k1
  14. "v1"
  15. 127.0.0.1:6379> get k2
  16. "v2"
  17. 127.0.0.1:6379>
  • Redis 类型错误（运行时错误）

在开启事务后，修改 k1 值为 11，k2 值为 22，但将 k2 的类型作为 List，在运行时检测类型错误，最终导致事务提交失败，此时事务并没有回滚，而是跳过错误命令继续执行， 结果 k1 值改变、k2 保留原值。

  1. 127.0.0.1:6379> set k1 v1
  2. OK
  3. 127.0.0.1:6379> set k1 v2
  4. OK
  5. 127.0.0.1:6379> MULTI
  6. OK
  7. 127.0.0.1:6379> set k1 11
  8. QUEUED
  9. 127.0.0.1:6379> lpush k2 22
  10. QUEUED
  11. 127.0.0.1:6379> EXEC
  12. 1) OK
  13. 2) (error) WRONGTYPE Operation against a key holding the wrong kind of value
  14. 127.0.0.1:6379> get k1
  15. "11"
  16. 127.0.0.1:6379> get k2
  17. "v2"
  18. 127.0.0.1:6379>

CAS 操作实现乐观锁

WATCH 命令可以为 Redis 事务提供 check-and-set （CAS）行为。

  • CAS? 乐观锁？Redis 官方的例子帮你理解

被 WATCH 的键会被监视，并会发觉这些键是否被改动过了。 如果有至少一个被监视的键在 EXEC 执行之前被修改了， 那么整个事务都会被取消， EXEC 返回 nil-reply 来表示事务已经失败。
举个例子， 假设我们需要原子性地为某个值进行增 1 操作（假设 INCR 不存在）。
首先我们可能会这样做：

  1. val = GET mykey
  2. val = val + 1
  3. SET mykey $val

上面的这个实现在只有一个客户端的时候可以执行得很好。 但是， 当多个客户端同时对同一个键进行这样的操作时， 就会产生竞争条件。举个例子， 如果客户端 A 和 B 都读取了键原来的值， 比如 10 ， 那么两个客户端都会将键的值设为 11 ， 但正确的结果应该是 12 才对。
有了 WATCH ，我们就可以轻松地解决这类问题了：

  1. WATCH mykey
  2. val = GET mykey
  3. val = val + 1
  4. MULTI
  5. SET mykey $val
  6. EXEC

使用上面的代码， 如果在 WATCH 执行之后， EXEC 执行之前， 有其他客户端修改了 mykey 的值， 那么当前客户端的事务就会失败。 程序需要做的， 就是不断重试这个操作， 直到没有发生碰撞为止。
这种形式的锁被称作乐观锁， 它是一种非常强大的锁机制。 并且因为大多数情况下， 不同的客户端会访问不同的键， 碰撞的情况一般都很少， 所以通常并不需要进行重试。

  • watch 是如何监视实现的呢？

Redis 使用 WATCH 命令来决定事务是继续执行还是回滚，那就需要在 MULTI 之前使用 WATCH 来监控某些键值对，然后使用 MULTI 命令来开启事务，执行对数据结构操作的各种命令，此时这些命令入队列。
当使用 EXEC 执行事务时，首先会比对 WATCH 所监控的键值对，如果没发生改变，它会执行事务队列中的命令，提交事务；如果发生变化，将不会执行事务中的任何命令，同时事务回滚。当然无论是否回滚，Redis 都会取消执行事务前的 WATCH 命令。
image.png

  • watch 命令实现监视

在事务开始前用 WATCH 监控 k1，之后修改 k1 为 11，说明事务开始前 k1 值被改变，MULTI 开始事务，修改 k1 值为 12，k2 为 22，执行 EXEC，发回 nil，说明事务回滚；查看下 k1、k2 的值都没有被事务中的命令所改变。

  1. 127.0.0.1:6379> set k1 v1
  2. OK
  3. 127.0.0.1:6379> set k2 v2
  4. OK
  5. 127.0.0.1:6379> WATCH k1
  6. OK
  7. 127.0.0.1:6379> set k1 11
  8. OK
  9. 127.0.0.1:6379> MULTI
  10. OK
  11. 127.0.0.1:6379> set k1 12
  12. QUEUED
  13. 127.0.0.1:6379> set k2 22
  14. QUEUED
  15. 127.0.0.1:6379> EXEC
  16. (nil)
  17. 127.0.0.1:6379> get k1
  18. "11"
  19. 127.0.0.1:6379> get k2
  20. "v2"
  21. 127.0.0.1:6379>

  • UNWATCH 取消监视

    127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> set k2 v2
OK
127.0.0.1:6379> WATCH k1
OK
127.0.0.1:6379> set k1 11
OK
127.0.0.1:6379> UNWATCH
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set k1 12
QUEUED
127.0.0.1:6379> set k2 22
QUEUED
127.0.0.1:6379> exec
1) OK
2) OK
127.0.0.1:6379> get k1
"12"
127.0.0.1:6379> get k2
"22"
127.0.0.1:6379>

    著作权归https://pdai.tech所有。 链接：https://pdai.tech/md/db/nosql-redis/db-redis-x-trans.html

    Redis 事务执行步骤

    通过上文命令执行，很显然 Redis 事务执行是三个阶段：

  • 开启：以 MULTI 开始一个事务

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

当一个客户端切换到事务状态之后， 服务器会根据这个客户端发来的不同命令执行不同的操作：

  • 如果客户端发送的命令为 EXEC 、 DISCARD 、 WATCH 、 MULTI 四个命令的其中一个， 那么服务器立即执行这个命令。
  • 与此相反， 如果客户端发送的命令是 EXEC 、 DISCARD 、 WATCH 、 MULTI 四个命令以外的其他命令， 那么服务器并不立即执行这个命令， 而是将这个命令放入一个事务队列里面， 然后向客户端返回 QUEUED 回复。

image.png

更深入的理解

我们再通过几个问题来深入理解 Redis 事务。

为什么 Redis 不支持回滚？

如果你有使用关系式数据库的经验， 那么 “Redis 在事务失败时不进行回滚，而是继续执行余下的命令” 这种做法可能会让你觉得有点奇怪。
以下是这种做法的优点：

  • Redis 命令只会因为错误的语法而失败（并且这些问题不能在入队时发现），或是命令用在了错误类型的键上面：这也就是说，从实用性的角度来说，失败的命令是由编程错误造成的，而这些错误应该在开发的过程中被发现，而不应该出现在生产环境中。
  • 因为不需要对回滚进行支持，所以 Redis 的内部可以保持简单且快速。

有种观点认为 Redis 处理事务的做法会产生 bug ， 然而需要注意的是， 在通常情况下， 回滚并不能解决编程错误带来的问题。 举个例子， 如果你本来想通过 INCR 命令将键的值加上 1 ， 却不小心加上了 2 ， 又或者对错误类型的键执行了 INCR ， 回滚是没有办法处理这些情况的。

如何理解 Redis 与事务的 ACID？

一般来说，事务有四个性质称为 ACID，分别是原子性，一致性，隔离性和持久性。这是基础，但是很多文章对 Redis 是否支持 ACID 有一些异议，我觉的有必要梳理下：

  • 原子性 atomicity

首先通过上文知道 运行期的错误是不会回滚的，很多文章由此说 Redis 事务违背原子性的；而官方文档认为是遵从原子性的。
Redis 官方文档给的理解是，Redis 的事务是原子性的：所有的命令，要么全部执行，要么全部不执行。而不是完全成功。

  • 一致性 consistency

redis 事务可以保证命令失败的情况下得以回滚，数据能恢复到没有执行之前的样子，是保证一致性的，除非 redis 进程意外终结。

  • 隔离性 Isolation

redis 事务是严格遵守隔离性的，原因是 redis 是单进程单线程模式 (v6.0 之前），可以保证命令执行过程中不会被其他客户端命令打断。
但是，Redis 不像其它结构化数据库有隔离级别这种设计。

  • 持久性 Durability

redis 事务是不保证持久性的，这是因为 redis 持久化策略中不管是 RDB 还是 AOF 都是异步执行的，不保证持久性是出于对性能的考虑。

Redis 事务其它实现

  • 基于 Lua 脚本，Redis 可以保证脚本内的命令一次性、按顺序地执行，其同时也不提供事务运行错误的回滚，执行过程中如果部分命令运行错误，剩下的命令还是会继续运行完
  • 基于中间标记变量，通过另外的标记变量来标识事务是否执行完成，读取数据时先读取该标记变量判断是否事务执行完成。但这样会需要额外写代码实现，比较繁琐