redis事务

我不是女神ヾ 2022-01-15 23:23 330阅读 0赞

Redis 通过 [MULTI][] 、 [DISCARD][] 、 [EXEC][] 和 [WATCH][] 四个命令来实现事务功能， 本章首先讨论使用 [MULTI][] 、 [DISCARD][] 和 [EXEC][] 三个命令实现的一般事务， 然后再来讨论带有 [WATCH][] 的事务的实现。

因为事务的安全性也非常重要， 所以本章最后通过常见的 ACID 性质对 Redis 事务的安全性进行了说明。

## 事务 ##

事务提供了一种“将多个命令打包， 然后一次性、按顺序地执行”的机制， 并且事务在执行的期间不会主动中断 —— 服务器在执行完事务中的所有命令之后， 才会继续处理其他客户端的其他命令。

以下是一个事务的例子， 它先以 [MULTI][] 开始一个事务， 然后将多个命令入队到事务中， 最后由 [EXEC][] 命令触发事务， 一并执行事务中的所有命令：

redis> MULTI
    OK
    
    redis> SET book-name "Mastering C++ in 21 days"
    QUEUED
    
    redis> GET book-name
    QUEUED
    
    redis> SADD tag "C++" "Programming" "Mastering Series"
    QUEUED
    
    redis> SMEMBERS tag
    QUEUED
    
    redis> EXEC
    1) OK
    2) "Mastering C++ in 21 days"
    3) (integer) 3
    4) 1) "Mastering Series"
       2) "C++"
       3) "Programming"

一个事务从开始到执行会经历以下三个阶段：

1.  开始事务。
2.  命令入队。
3.  执行事务。

下文将分别介绍事务的这三个阶段。

## 开始事务 ##

[MULTI][] 命令的执行标记着事务的开始：

redis> MULTI
    OK

这个命令唯一做的就是， 将客户端的 `REDIS_MULTI` 选项打开， 让客户端从非事务状态切换到事务状态。

![digraph normal\_to\_transaction \{      rankdir = LR;      node \[shape = circle, style = filled\];      edge \[style = bold\];      label = "客户端状态的切换";      normal \[label = "非事务状态", fillcolor = "\#FADCAD"\];      transaction \[label = "事务状态", fillcolor = "\#A8E270"\];      normal -> transaction \[label = "打开选项\\nREDIS\_MULTI"\]; \}][digraph normal_to_transaction _ rankdir _ LR_ node _shape _ circle_ style _ filled_ edge _style _ bold_ label _ _ normal _label _ _ fillcolor _ _FADCAD_ transaction _label _ _ fillcolor _ _A8E270_ normal -_ transaction _label _ _nREDIS_MULTI_]

## 命令入队 ##

当客户端处于非事务状态下时， 所有发送给服务器端的命令都会立即被服务器执行：

redis> SET msg "hello moto"
    OK
    
    redis> GET msg
    "hello moto"

但是， 当客户端进入事务状态之后， 服务器在收到来自客户端的命令时， 不会立即执行命令， 而是将这些命令全部放进一个事务队列里， 然后返回 `QUEUED` ， 表示命令已入队：

redis> MULTI
    OK
    
    redis> SET msg "hello moto"
    QUEUED
    
    redis> GET msg
    QUEUED

以下流程图展示了这一行为：

![digraph enqueue \{      node \[shape = plaintext, style = filled\];      edge \[style = bold\];      command\_in \[label = "服务器接到来自客户端的命令"\];      in\_transaction\_or\_not \[label = "客户端是否正处于事务状态？", shape = diamond, fillcolor = "\#95BBE3"\];      enqueu\_command \[label = "将命令放进事务队列里", fillcolor = "\#A8E270"\];      return\_enqueued \[label = "向客户端返回 QUEUED 字符串\\n表示命令已入队", fillcolor = "\#A8E270"\];      exec\_command \[label = "执行命令", fillcolor = "\#FADCAD"\];      return\_command\_result \[label = "向客户端返回命令的执行结果", fillcolor = "\#FADCAD"\];      //       command\_in -> in\_transaction\_or\_not;      in\_transaction\_or\_not -> enqueu\_command \[label = "是"\];      in\_transaction\_or\_not -> exec\_command \[label = "否"\];      exec\_command -> return\_command\_result;      enqueu\_command -> return\_enqueued; \}][digraph enqueue _ node _shape _ plaintext_ style _ filled_ edge _style _ bold_ command_in _label _ _ in_transaction_or_not _label _ _ shape _ diamond_ fillcolor _ _95BBE3_ enqueu_command _label _ _ fillcolor _ _A8E270_ return_enqueued _label _ _ QUEUED _n_ fillcolor _ _A8E270_ exec_command _label _ _ fillcolor _ _FADCAD_ return_command_result _label _ _ fillcolor _ _FADCAD_ _ command_in -_ in_transaction_or_not_ in_transaction_or_not -_ enqueu_command _label _ _ in_transaction_or_not -_ exec_command _label _ _ exec_command -_ return_command_result_ enqueu_command -_ return_enqueued_]

事务队列是一个数组， 每个数组项是都包含三个属性：

1.  要执行的命令（cmd）。
2.  命令的参数（argv）。
3.  参数的个数（argc）。

举个例子， 如果客户端执行以下命令：

那么程序将为客户端创建以下事务队列：

<table> 
 <thead> 
  <tr> 
   <th>数组索引</th> 
   <th>cmd</th> 
   <th>argv</th> 
   <th>argc</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>0</code></td> 
   <td><code>SET</code></td> 
   <td><code>["book-name",&nbsp;"Mastering&nbsp;C++&nbsp;in&nbsp;21&nbsp;days"]</code></td> 
   <td><code>2</code></td> 
  </tr> 
  <tr> 
   <td><code>1</code></td> 
   <td><code>GET</code></td> 
   <td><code>["book-name"]</code></td> 
   <td><code>1</code></td> 
  </tr> 
  <tr> 
   <td><code>2</code></td> 
   <td><code>SADD</code></td> 
   <td><code>["tag",&nbsp;"C++",&nbsp;"Programming",&nbsp;"Mastering&nbsp;Series"]</code></td> 
   <td><code>4</code></td> 
  </tr> 
  <tr> 
   <td><code>3</code></td> 
   <td><code>SMEMBERS</code></td> 
   <td><code>["tag"]</code></td> 
   <td><code>1</code></td> 
  </tr> 
 </tbody> 
</table>

## 执行事务 ##

前面说到， 当客户端进入事务状态之后， 客户端发送的命令就会被放进事务队列里。

但其实并不是所有的命令都会被放进事务队列， 其中的例外就是 [EXEC][] 、 [DISCARD][] 、 [MULTI][] 和 [WATCH][] 这四个命令 —— 当这四个命令从客户端发送到服务器时， 它们会像客户端处于非事务状态一样， 直接被服务器执行：

![digraph not\_enque\_command \{      node \[shape = plaintext, style = filled\];      edge \[style = bold\];      command\_in \[label = "服务器接到来自客户端的命令"\];      in\_transaction\_or\_not \[label = "客户端是否正处于事务状态？", shape = diamond, fillcolor = "\#95BBE3"\];      not\_exec\_and\_discard \[label = "命令是否\\nEXEC 、 DISCARD 、\\nMULTI 或 WATCH ？", shape = diamond, fillcolor = "\#FFC1C1"\];      enqueu\_command \[label = "将命令放进事务队列里", fillcolor = "\#A8E270"\];      return\_enqueued \[label = "向客户端返回 QUEUED 字符串\\n表示命令已入队", fillcolor = "\#A8E270"\];      exec\_command \[label = "执行命令", fillcolor = "\#FADCAD"\];      return\_command\_result \[label = "向客户端返回命令的执行结果", fillcolor = "\#FADCAD"\];      //       command\_in -> in\_transaction\_or\_not;      in\_transaction\_or\_not -> not\_exec\_and\_discard \[label = "是"\];      not\_exec\_and\_discard -> enqueu\_command \[label = "否"\];      not\_exec\_and\_discard -> exec\_command \[label = "是"\];      in\_transaction\_or\_not -> exec\_command \[label = "否"\];      exec\_command -> return\_command\_result;      enqueu\_command -> return\_enqueued; \}][digraph not_enque_command _ node _shape _ plaintext_ style _ filled_ edge _style _ bold_ command_in _label _ _ in_transaction_or_not _label _ _ shape _ diamond_ fillcolor _ _95BBE3_ not_exec_and_discard _label _ _nEXEC _ DISCARD _nMULTI _ WATCH _ shape _ diamond_ fillcolor _ _FFC1C1_ enqueu_command _label _ _ fillcolor _ _A8E270_ return_enqueued _label _ _ QUEUED _n_ fillcolor _ _A8E270_ exec_command _label _ _ fillcolor _ _FADCAD_ return_command_result _label _ _ fillcolor _ _FADCAD_ _ command_in -_ in_transaction_or_not_ in_transaction_or_not -_ not_exec_and_discard _label _ _ not_exec_and_discard -_ enqueu_command _label _ _ not_exec_and_discard -_ exec_command _label _ _ in_transaction_or_not -_ exec_command _label _ _ exec_command -_ return_command_result_ enqueu_command -_ return_enqueued_]

如果客户端正处于事务状态， 那么当 [EXEC][] 命令执行时， 服务器根据客户端所保存的事务队列， 以先进先出（FIFO）的方式执行事务队列中的命令： 最先入队的命令最先执行， 而最后入队的命令最后执行。

比如说，对于以下事务队列：

程序会首先执行 [SET][] 命令， 然后执行 [GET][] 命令， 再然后执行 [SADD][] 命令， 最后执行 [SMEMBERS][] 命令。

执行事务中的命令所得的结果会以 FIFO 的顺序保存到一个回复队列中。

比如说，对于上面给出的事务队列，程序将为队列中的命令创建如下回复队列：

<table> 
 <thead> 
  <tr> 
   <th>数组索引</th> 
   <th>回复类型</th> 
   <th>回复内容</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>0</code></td> 
   <td>status code reply</td> 
   <td><code>OK</code></td> 
  </tr> 
  <tr> 
   <td><code>1</code></td> 
   <td>bulk reply</td> 
   <td><code>"Mastering&nbsp;C++&nbsp;in&nbsp;21&nbsp;days"</code></td> 
  </tr> 
  <tr> 
   <td><code>2</code></td> 
   <td>integer reply</td> 
   <td><code>3</code></td> 
  </tr> 
  <tr> 
   <td><code>3</code></td> 
   <td>multi-bulk reply</td> 
   <td><code>["Mastering&nbsp;Series",&nbsp;"C++",&nbsp;"Programming"]</code></td> 
  </tr> 
 </tbody> 
</table>

当事务队列里的所有命令被执行完之后， [EXEC][] 命令会将回复队列作为自己的执行结果返回给客户端， 客户端从事务状态返回到非事务状态， 至此， 事务执行完毕。

事务的整个执行过程可以用以下伪代码表示：

def execute_transaction():
    
        # 创建空白的回复队列
        reply_queue = []
    
        # 取出事务队列里的所有命令、参数和参数数量
        for cmd, argv, argc in client.transaction_queue:
    
            # 执行命令，并取得命令的返回值
            reply = execute_redis_command(cmd, argv, argc)
    
            # 将返回值追加到回复队列末尾
            reply_queue.append(reply)
    
        # 清除客户端的事务状态
        clear_transaction_state(client)
    
        # 清空事务队列
        clear_transaction_queue(client)
    
        # 将事务的执行结果返回给客户端
        send_reply_to_client(client, reply_queue)

## 在事务和非事务状态下执行命令 ##

无论在事务状态下， 还是在非事务状态下， Redis 命令都由同一个函数执行， 所以它们共享很多服务器的一般设置， 比如 AOF 的配置、RDB 的配置，以及内存限制，等等。

不过事务中的命令和普通命令在执行上还是有一点区别的，其中最重要的两点是：

1.  非事务状态下的命令以单个命令为单位执行，前一个命令和后一个命令的客户端不一定是同一个；
    
    而事务状态则是以一个事务为单位，执行事务队列中的所有命令：除非当前事务执行完毕，否则服务器不会中断事务，也不会执行其他客户端的其他命令。
2.  在非事务状态下，执行命令所得的结果会立即被返回给客户端；
    
    而事务则是将所有命令的结果集合到回复队列，再作为 [EXEC][] 命令的结果返回给客户端。

## 事务状态下的 DISCARD 、 MULTI 和 WATCH 命令 ##

除了 [EXEC][] 之外， 服务器在客户端处于事务状态时， 不加入到事务队列而直接执行的另外三个命令是 [DISCARD][] 、 [MULTI][] 和 [WATCH][] 。

[DISCARD][] 命令用于取消一个事务， 它清空客户端的整个事务队列， 然后将客户端从事务状态调整回非事务状态， 最后返回字符串 `OK` 给客户端， 说明事务已被取消。

Redis 的事务是不可嵌套的， 当客户端已经处于事务状态， 而客户端又再向服务器发送 [MULTI][] 时， 服务器只是简单地向客户端发送一个错误， 然后继续等待其他命令的入队。 [MULTI][] 命令的发送不会造成整个事务失败， 也不会修改事务队列中已有的数据。

[WATCH][] 只能在客户端进入事务状态之前执行， 在事务状态下发送 [WATCH][] 命令会引发一个错误， 但它不会造成整个事务失败， 也不会修改事务队列中已有的数据（和前面处理 [MULTI][] 的情况一样）。

## 带 WATCH 的事务 ##

[WATCH][] 命令用于在事务开始之前监视任意数量的键： 当调用 [EXEC][] 命令执行事务时， 如果任意一个被监视的键已经被其他客户端修改了， 那么整个事务不再执行， 直接返回失败。

以下示例展示了一个执行失败的事务例子：

redis> WATCH name
    OK
    
    redis> MULTI
    OK
    
    redis> SET name peter
    QUEUED
    
    redis> EXEC
    (nil)

以下执行序列展示了上面的例子是如何失败的：

<table> 
 <thead> 
  <tr> 
   <th>时间</th> 
   <th>客户端 A</th> 
   <th>客户端 B</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>T1</td> 
   <td><code>WATCH&nbsp;name</code></td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>T2</td> 
   <td><code>MULTI</code></td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>T3</td> 
   <td><code>SET&nbsp;name&nbsp;peter</code></td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>T4</td> 
   <td>&nbsp;</td> 
   <td><code>SET&nbsp;name&nbsp;john</code></td> 
  </tr> 
  <tr> 
   <td>T5</td> 
   <td><code>EXEC</code></td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

在时间 T4 ，客户端 B 修改了 `name` 键的值， 当客户端 A 在 T5 执行 [EXEC][] 时，Redis 会发现 `name` 这个被监视的键已经被修改， 因此客户端 A 的事务不会被执行，而是直接返回失败。

下文就来介绍 [WATCH][] 的实现机制，并且看看事务系统是如何检查某个被监视的键是否被修改，从而保证事务的安全性的。

## WATCH 命令的实现 ##

在每个代表数据库的 `redis.h/redisDb` 结构类型中， 都保存了一个 `watched_keys` 字典， 字典的键是这个数据库被监视的键， 而字典的值则是一个链表， 链表中保存了所有监视这个键的客户端。

比如说，以下字典就展示了一个 `watched_keys` 字典的例子：

![digraph watched\_keys \{      rankdir = LR;      node \[shape = record, style = filled\];      edge \[style = bold\];      // keys      watched\_keys \[label = "watched\_keys |<key1> key1 |<key2> key2 |<key3> key3 | ... |<keyN> keyN", fillcolor = "\#A8E270"\];      // clients blocking for key1     client1 \[label = "client1", fillcolor = "\#95BBE3"\];     client5 \[label = "client5", fillcolor = "\#95BBE3"\];     client2 \[label = "client2", fillcolor = "\#95BBE3"\];     null\_1 \[label = "NULL", shape = plaintext\];          watched\_keys:key1 -> client2;     client2 -> client5;     client5 -> client1;     client1 -> null\_1;      // clients blocking for key2     client7 \[label = "client7", fillcolor = "\#95BBE3"\];     null\_2 \[label = "NULL", shape = plaintext\];      watched\_keys:key2 -> client7;     client7 -> null\_2;      // key3      client3 \[label = "client3", fillcolor = "\#95BBE3"\];     client4 \[label = "client4", fillcolor = "\#95BBE3"\];     client6 \[label = "client6", fillcolor = "\#95BBE3"\];     null\_3 \[label = "NULL", shape = plaintext\];      watched\_keys:key3 -> client3;     client3 -> client4;     client4 -> client6;     client6 -> null\_3; \}][digraph watched_keys _ rankdir _ LR_ node _shape _ record_ style _ filled_ edge _style _ bold_ _ keys watched_keys _label _ _watched_keys _key1_ key1 _key2_ key2 _key3_ key3 _ ... _keyN_ keyN_ fillcolor _ _A8E270_ _ clients blocking for key1 client1 _label _ _client1_ fillcolor _ _95BBE3_ client5 _label _ _client5_ fillcolor _ _95BBE3_ client2 _label _ _client2_ fillcolor _ _95BBE3_ null_1 _label _ _NULL_ shape _ plaintext_ watched_keys_key1 -_ client2_ client2 -_ client5_ client5 -_ client1_ client1 -_ null_1_ _ clients blocking for key2 client7 _label _ _client7_ fillcolor _ _95BBE3_ null_2 _label _ _NULL_ shape _ plaintext_ watched_keys_key2 -_ client7_ client7 -_ null_2_ _ key3 client3 _label _ _client3_ fillcolor _ _95BBE3_ client4 _label _ _client4_ fillcolor _ _95BBE3_ client6 _label _ _client6_ fillcolor _ _95BBE3_ null_3 _label _ _NULL_ shape _ plaintext_ watched_keys_key3 -_ client3_ client3 -_ client4_ client4 -_ client6_ client6 -_ null_3_]

其中， 键 `key1` 正在被 `client2` 、 `client5` 和 `client1` 三个客户端监视， 其他一些键也分别被其他别的客户端监视着。

[WATCH][] 命令的作用， 就是将当前客户端和要监视的键在 `watched_keys` 中进行关联。

举个例子， 如果当前客户端为 `client10086` ， 那么当客户端执行 `WATCH key1 key2` 时， 前面展示的 `watched_keys` 将被修改成这个样子：

![digraph new\_watched\_keys \{      rankdir = LR;      node \[shape = record, style = filled\];      edge \[style = bold\];      // keys      watched\_keys \[label = "watched\_keys |<key1> key1 |<key2> key2 |<key3> key3 | ... |<keyN> keyN", fillcolor = "\#A8E270"\];      // clients blocking for key1     client1 \[label = "client1", fillcolor = "\#95BBE3"\];     client5 \[label = "client5", fillcolor = "\#95BBE3"\];     client2 \[label = "client2", fillcolor = "\#95BBE3"\];     client10086 \[label = "client10086", fillcolor = "\#FFC1C1"\];     null\_1 \[label = "NULL", shape = plaintext\];          watched\_keys:key1 -> client2;     client2 -> client5;     client5 -> client1;     client1 -> client10086;     client10086 -> null\_1;      // clients blocking for key2     client7 \[label = "client7", fillcolor = "\#95BBE3"\];     client10086\_2 \[label = "client10086", fillcolor = "\#FFC1C1"\];     null\_2 \[label = "NULL", shape = plaintext\];      watched\_keys:key2 -> client7;     client7 -> client10086\_2;     client10086\_2 -> null\_2;      // key3      client3 \[label = "client3", fillcolor = "\#95BBE3"\];     client4 \[label = "client4", fillcolor = "\#95BBE3"\];     client6 \[label = "client6", fillcolor = "\#95BBE3"\];     null\_3 \[label = "NULL", shape = plaintext\];      watched\_keys:key3 -> client3;     client3 -> client4;     client4 -> client6;     client6 -> null\_3; \}][digraph new_watched_keys _ rankdir _ LR_ node _shape _ record_ style _ filled_ edge _style _ bold_ _ keys watched_keys _label _ _watched_keys _key1_ key1 _key2_ key2 _key3_ key3 _ ... _keyN_ keyN_ fillcolor _ _A8E270_ _ clients blocking for key1 client1 _label _ _client1_ fillcolor _ _95BBE3_ client5 _label _ _client5_ fillcolor _ _95BBE3_ client2 _label _ _client2_ fillcolor _ _95BBE3_ client10086 _label _ _client10086_ fillcolor _ _FFC1C1_ null_1 _label _ _NULL_ shape _ plaintext_ watched_keys_key1 -_ client2_ client2 -_ client5_ client5 -_ client1_ client1 -_ client10086_ client10086 -_ null_1_ _ clients blocking for key2 client7 _label _ _client7_ fillcolor _ _95BBE3_ client10086_2 _label _ _client10086_ fillcolor _ _FFC1C1_ null_2 _label _ _NULL_ shape _ plaintext_ watched_keys_key2 -_ client7_ client7 -_ client10086_2_ client10086_2 -_ null_2_ _ key3 client3 _label _ _client3_ fillcolor _ _95BBE3_ client4 _label _ _client4_ fillcolor _ _95BBE3_ client6 _label _ _client6_ fillcolor _ _95BBE3_ null_3 _label _ _NULL_ shape _ plaintext_ watched_keys_key3 -_ client3_ client3 -_ client4_ client4 -_ client6_ client6 -_ null_3_]

通过 `watched_keys` 字典， 如果程序想检查某个键是否被监视， 那么它只要检查字典中是否存在这个键即可； 如果程序要获取监视某个键的所有客户端， 那么只要取出键的值（一个链表）， 然后对链表进行遍历即可。

## WATCH 的触发 ##

在任何对数据库键空间（key space）进行修改的命令成功执行之后 （比如 [FLUSHDB][] 、 [SET][] 、 [DEL][] 、 [LPUSH][] 、 [SADD][] 、 [ZREM][] ，诸如此类）， `multi.c/touchWatchedKey` 函数都会被调用 —— 它检查数据库的 `watched_keys` 字典， 看是否有客户端在监视已经被命令修改的键， 如果有的话， 程序将所有监视这个/这些被修改键的客户端的 `REDIS_DIRTY_CAS` 选项打开：

![digraph dirty\_cas \{      rankdir = LR;      node \[shape = circle, style = filled\];      edge \[style = bold\];      label = "客户端状态的切换";      normal \[label = "非事务状态", fillcolor = "\#FADCAD"\];      transaction \[label = "事务状态", fillcolor = "\#A8E270"\];      dirty\_cas \[label = "事务安全性\\n已被破坏", fillcolor = "\#B22222"\];      normal -> transaction \[label = "打开选项\\nREDIS\_MULTI"\];      transaction -> dirty\_cas \[label = "打开选项\\nREDIS\_DIRTY\_CAS"\]; \}][digraph dirty_cas _ rankdir _ LR_ node _shape _ circle_ style _ filled_ edge _style _ bold_ label _ _ normal _label _ _ fillcolor _ _FADCAD_ transaction _label _ _ fillcolor _ _A8E270_ dirty_cas _label _ _n_ fillcolor _ _B22222_ normal -_ transaction _label _ _nREDIS_MULTI_ transaction -_ dirty_cas _label _ _nREDIS_DIRTY_CAS_]

当客户端发送 [EXEC][] 命令、触发事务执行时， 服务器会对客户端的状态进行检查：

*  如果客户端的 `REDIS_DIRTY_CAS` 选项已经被打开，那么说明被客户端监视的键至少有一个已经被修改了，事务的安全性已经被破坏。服务器会放弃执行这个事务，直接向客户端返回空回复，表示事务执行失败。
 *  如果 `REDIS_DIRTY_CAS` 选项没有被打开，那么说明所有监视键都安全，服务器正式执行事务。

可以用一段伪代码来表示这个检查：

def check_safety_before_execute_trasaction():
    
        if client.state & REDIS_DIRTY_CAS:
            # 安全性已破坏，清除事务状态
            clear_transaction_state(client)
            # 清空事务队列
            clear_transaction_queue(client)
            # 返回空回复给客户端
            send_empty_reply(client)
        else:
            # 安全性完好，执行事务
            execute_transaction()

举个例子，假设数据库的 `watched_keys` 字典如下图所示：

如果某个客户端对 `key1` 进行了修改（比如执行 `DEL key1` ）， 那么所有监视 `key1` 的客户端， 包括 `client2` 、 `client5` 和 `client1` 的 `REDIS_DIRTY_CAS` 选项都会被打开， 当客户端 `client2` 、 `client5` 和 `client1` 执行 [EXEC][] 的时候， 它们的事务都会以失败告终。

最后，当一个客户端结束它的事务时，无论事务是成功执行，还是失败， `watched_keys` 字典中和这个客户端相关的资料都会被清除。

## 四、为什么Redis不支持回滚？ ##

如果你具备关系型数据库的知识背景，你就会发现一个事实：在事务运行期间，虽然Redis命令可能会执行失败，但是Redis仍然会执行事务中余下的其他命令，而不会执行回滚操作，你可能会觉得这种行为很奇怪。

然而，这种行为也有其合理之处：

> 只有当被调用的Redis命令有语法错误时，这条命令才会执行失败（在将这个命令放入事务队列期间，Redis能够发现此类问题），或者对某个键执行不符合其数据类型的操作：实际上，这就意味着只有程序错误才会导致Redis命令执行失败，这种错误很有可能在程序开发期间发现，一般很少在生产环境发现。   
> Redis已经在系统内部进行功能简化，这样可以确保更快的运行速度，因为Redis不需要事务回滚的能力。

对于Redis事务的这种行为，有一个普遍的反对观点，那就是程序有可能会有缺陷（bug）。但是，你应当注意到：事务回滚并不能解决任何程序错误。例如，如果某个查询会将一个键的值递增2，而不是1，或者递增错误的键，那么事务回滚机制是没有办法解决这些程序问题的。请注意，没有人能解决程序员自己的错误，这种错误可能会导致Redis命令执行失败。正因为这些程序错误不大可能会进入生产环境，所以我们在开发Redis时选用更加简单和快速的方法，没有实现错误回滚的功能。

## 事务的 ACID 性质 ##

勘误：Redis 的事务是保证原子性的，本节的内容将原子性和回滚功能混淆了，等待修复中。 —— 2013.6.23

在传统的关系式数据库中，常常用 [ACID 性质][ACID]来检验事务功能的安全性。

Redis 事务保证了其中的一致性（C）和隔离性（I），但并不保证原子性（A）和持久性（D）。

以下四小节是关于这四个性质的详细讨论。

### 原子性（Atomicity） ###

单个 Redis 命令的执行是原子性的，但 Redis 没有在事务上增加任何维持原子性的机制，所以 Redis 事务的执行并不是原子性的。

如果一个事务队列中的所有命令都被成功地执行，那么称这个事务执行成功。

另一方面，如果 Redis 服务器进程在执行事务的过程中被停止 —— 比如接到 KILL 信号、宿主机器停机，等等，那么事务执行失败。

当事务失败时，Redis 也不会进行任何的重试或者回滚动作。

### 一致性（Consistency） ###

Redis 的一致性问题可以分为三部分来讨论：入队错误、执行错误、Redis 进程被终结。

入队错误

在命令入队的过程中，如果客户端向服务器发送了错误的命令，比如命令的参数数量不对，等等， 那么服务器将向客户端返回一个出错信息， 并且将客户端的事务状态设为 `REDIS_DIRTY_EXEC` 。

当客户端执行 [EXEC][] 命令时， Redis 会拒绝执行状态为 `REDIS_DIRTY_EXEC` 的事务， 并返回失败信息。

redis 127.0.0.1:6379> MULTI
    OK
    
    redis 127.0.0.1:6379> set key
    (error) ERR wrong number of arguments for 'set' command
    
    redis 127.0.0.1:6379> EXISTS key
    QUEUED
    
    redis 127.0.0.1:6379> EXEC
    (error) EXECABORT Transaction discarded because of previous errors.

因此，带有不正确入队命令的事务不会被执行，也不会影响数据库的一致性。

执行错误

如果命令在事务执行的过程中发生错误，比如说，对一个不同类型的 key 执行了错误的操作， 那么 Redis 只会将错误包含在事务的结果中， 这不会引起事务中断或整个失败，不会影响已执行事务命令的结果，也不会影响后面要执行的事务命令， 所以它对事务的一致性也没有影响。

Redis 进程被终结

如果 Redis 服务器进程在执行事务的过程中被其他进程终结，或者被管理员强制杀死，那么根据 Redis 所使用的持久化模式，可能有以下情况出现：

*  内存模式：如果 Redis 没有采取任何持久化机制，那么重启之后的数据库总是空白的，所以数据总是一致的。
 *  RDB 模式：在执行事务时，Redis 不会中断事务去执行保存 RDB 的工作，只有在事务执行之后，保存 RDB 的工作才有可能开始。所以当 RDB 模式下的 Redis 服务器进程在事务中途被杀死时，事务内执行的命令，不管成功了多少，都不会被保存到 RDB 文件里。恢复数据库需要使用现有的 RDB 文件，而这个 RDB 文件的数据保存的是最近一次的数据库快照（snapshot），所以它的数据可能不是最新的，但只要 RDB 文件本身没有因为其他问题而出错，那么还原后的数据库就是一致的。
 *  AOF 模式：因为保存 AOF 文件的工作在后台线程进行，所以即使是在事务执行的中途，保存 AOF 文件的工作也可以继续进行，因此，根据事务语句是否被写入并保存到 AOF 文件，有以下两种情况发生：
    
    1）如果事务语句未写入到 AOF 文件，或 AOF 未被 SYNC 调用保存到磁盘，那么当进程被杀死之后，Redis 可以根据最近一次成功保存到磁盘的 AOF 文件来还原数据库，只要 AOF 文件本身没有因为其他问题而出错，那么还原后的数据库总是一致的，但其中的数据不一定是最新的。
    
    2）如果事务的部分语句被写入到 AOF 文件，并且 AOF 文件被成功保存，那么不完整的事务执行信息就会遗留在 AOF 文件里，当重启 Redis 时，程序会检测到 AOF 文件并不完整，Redis 会退出，并报告错误。需要使用 redis-check-aof 工具将部分成功的事务命令移除之后，才能再次启动服务器。还原之后的数据总是一致的，而且数据也是最新的（直到事务执行之前为止）。

### 隔离性（Isolation） ###

Redis 是单进程程序，并且它保证在执行事务时，不会对事务进行中断，事务可以运行直到执行完所有事务队列中的命令为止。因此，Redis 的事务是总是带有隔离性的。

### 持久性（Durability） ###

因为事务不过是用队列包裹起了一组 Redis 命令，并没有提供任何额外的持久性功能，所以事务的持久性由 Redis 所使用的持久化模式决定：

*  在单纯的内存模式下，事务肯定是不持久的。
 *  在 RDB 模式下，服务器可能在事务执行之后、RDB 文件更新之前的这段时间失败，所以 RDB 模式下的 Redis 事务也是不持久的。
 *  在 AOF 的“总是 SYNC ”模式下，事务的每条命令在执行成功之后，都会立即调用 `fsync` 或 `fdatasync` 将事务数据写入到 AOF 文件。但是，这种保存是由后台线程进行的，主线程不会阻塞直到保存成功，所以从命令执行成功到数据保存到硬盘之间，还是有一段非常小的间隔，所以这种模式下的事务也是不持久的。
    
    其他 AOF 模式也和“总是 SYNC ”模式类似，所以它们都是不持久的。

## 小结 ##

*  事务提供了一种将多个命令打包，然后一次性、有序地执行的机制。
 *  事务在执行过程中不会被中断，所有事务命令执行完之后，事务才能结束。
 *  多个命令会被入队到事务队列中，然后按先进先出（FIFO）的顺序执行。
 *  带 `WATCH` 命令的事务会将客户端和被监视的键在数据库的 `watched_keys` 字典中进行关联，当键被修改时，程序会将所有监视被修改键的客户端的 `REDIS_DIRTY_CAS` 选项打开。
 *  只有在客户端的 `REDIS_DIRTY_CAS` 选项未被打开时，才能执行事务，否则事务直接返回失败。
 *  Redis 的事务保证了 ACID 中的一致性（C）和隔离性（I），但并不保证原子性（A）和持久性（D）。
 *  redis事物不支持事物回滚

文章来源：[https://redisbook.readthedocs.io/en/latest/feature/transaction.html][https_redisbook.readthedocs.io_en_latest_feature_transaction.html]

[MULTI]: http://redis.readthedocs.org/en/latest/transaction/multi.html#multi
[DISCARD]: http://redis.readthedocs.org/en/latest/transaction/discard.html#discard
[EXEC]: http://redis.readthedocs.org/en/latest/transaction/exec.html#exec
[WATCH]: http://redis.readthedocs.org/en/latest/transaction/watch.html#watch
[digraph normal_to_transaction _ rankdir _ LR_ node _shape _ circle_ style _ filled_ edge _style _ bold_ label _ _ normal _label _ _ fillcolor _ _FADCAD_ transaction _label _ _ fillcolor _ _A8E270_ normal -_ transaction _label _ _nREDIS_MULTI_]: /images/20220115/2c5698abd8834ef299338c75971bff3c.png
[digraph enqueue _ node _shape _ plaintext_ style _ filled_ edge _style _ bold_ command_in _label _ _ in_transaction_or_not _label _ _ shape _ diamond_ fillcolor _ _95BBE3_ enqueu_command _label _ _ fillcolor _ _A8E270_ return_enqueued _label _ _ QUEUED _n_ fillcolor _ _A8E270_ exec_command _label _ _ fillcolor _ _FADCAD_ return_command_result _label _ _ fillcolor _ _FADCAD_ _ command_in -_ in_transaction_or_not_ in_transaction_or_not -_ enqueu_command _label _ _ in_transaction_or_not -_ exec_command _label _ _ exec_command -_ return_command_result_ enqueu_command -_ return_enqueued_]: /images/20220115/10c283cf9a5942399f486b61b8d86e71.png
[digraph not_enque_command _ node _shape _ plaintext_ style _ filled_ edge _style _ bold_ command_in _label _ _ in_transaction_or_not _label _ _ shape _ diamond_ fillcolor _ _95BBE3_ not_exec_and_discard _label _ _nEXEC _ DISCARD _nMULTI _ WATCH _ shape _ diamond_ fillcolor _ _FFC1C1_ enqueu_command _label _ _ fillcolor _ _A8E270_ return_enqueued _label _ _ QUEUED _n_ fillcolor _ _A8E270_ exec_command _label _ _ fillcolor _ _FADCAD_ return_command_result _label _ _ fillcolor _ _FADCAD_ _ command_in -_ in_transaction_or_not_ in_transaction_or_not -_ not_exec_and_discard _label _ _ not_exec_and_discard -_ enqueu_command _label _ _ not_exec_and_discard -_ exec_command _label _ _ in_transaction_or_not -_ exec_command _label _ _ exec_command -_ return_command_result_ enqueu_command -_ return_enqueued_]: /images/20220115/ff43d5d5118941548e1b9261b0e284c3.png
[SET]: http://redis.readthedocs.org/en/latest/string/set.html#set
[GET]: http://redis.readthedocs.org/en/latest/string/get.html#get
[SADD]: http://redis.readthedocs.org/en/latest/set/sadd.html#sadd
[SMEMBERS]: http://redis.readthedocs.org/en/latest/set/smembers.html#smembers
[digraph watched_keys _ rankdir _ LR_ node _shape _ record_ style _ filled_ edge _style _ bold_ _ keys watched_keys _label _ _watched_keys _key1_ key1 _key2_ key2 _key3_ key3 _ ... _keyN_ keyN_ fillcolor _ _A8E270_ _ clients blocking for key1 client1 _label _ _client1_ fillcolor _ _95BBE3_ client5 _label _ _client5_ fillcolor _ _95BBE3_ client2 _label _ _client2_ fillcolor _ _95BBE3_ null_1 _label _ _NULL_ shape _ plaintext_ watched_keys_key1 -_ client2_ client2 -_ client5_ client5 -_ client1_ client1 -_ null_1_ _ clients blocking for key2 client7 _label _ _client7_ fillcolor _ _95BBE3_ null_2 _label _ _NULL_ shape _ plaintext_ watched_keys_key2 -_ client7_ client7 -_ null_2_ _ key3 client3 _label _ _client3_ fillcolor _ _95BBE3_ client4 _label _ _client4_ fillcolor _ _95BBE3_ client6 _label _ _client6_ fillcolor _ _95BBE3_ null_3 _label _ _NULL_ shape _ plaintext_ watched_keys_key3 -_ client3_ client3 -_ client4_ client4 -_ client6_ client6 -_ null_3_]: /images/20220115/08dd67d44bea430099b1a12a749e6e5e.png
[digraph new_watched_keys _ rankdir _ LR_ node _shape _ record_ style _ filled_ edge _style _ bold_ _ keys watched_keys _label _ _watched_keys _key1_ key1 _key2_ key2 _key3_ key3 _ ... _keyN_ keyN_ fillcolor _ _A8E270_ _ clients blocking for key1 client1 _label _ _client1_ fillcolor _ _95BBE3_ client5 _label _ _client5_ fillcolor _ _95BBE3_ client2 _label _ _client2_ fillcolor _ _95BBE3_ client10086 _label _ _client10086_ fillcolor _ _FFC1C1_ null_1 _label _ _NULL_ shape _ plaintext_ watched_keys_key1 -_ client2_ client2 -_ client5_ client5 -_ client1_ client1 -_ client10086_ client10086 -_ null_1_ _ clients blocking for key2 client7 _label _ _client7_ fillcolor _ _95BBE3_ client10086_2 _label _ _client10086_ fillcolor _ _FFC1C1_ null_2 _label _ _NULL_ shape _ plaintext_ watched_keys_key2 -_ client7_ client7 -_ client10086_2_ client10086_2 -_ null_2_ _ key3 client3 _label _ _client3_ fillcolor _ _95BBE3_ client4 _label _ _client4_ fillcolor _ _95BBE3_ client6 _label _ _client6_ fillcolor _ _95BBE3_ null_3 _label _ _NULL_ shape _ plaintext_ watched_keys_key3 -_ client3_ client3 -_ client4_ client4 -_ client6_ client6 -_ null_3_]: /images/20220115/2b3d933079fe4e6bb3a8987c0f3f0b8a.png
[FLUSHDB]: http://redis.readthedocs.org/en/latest/server/flushdb.html#flushdb
[DEL]: http://redis.readthedocs.org/en/latest/key/del.html#del
[LPUSH]: http://redis.readthedocs.org/en/latest/list/lpush.html#lpush
[ZREM]: http://redis.readthedocs.org/en/latest/sorted_set/zrem.html#zrem
[digraph dirty_cas _ rankdir _ LR_ node _shape _ circle_ style _ filled_ edge _style _ bold_ label _ _ normal _label _ _ fillcolor _ _FADCAD_ transaction _label _ _ fillcolor _ _A8E270_ dirty_cas _label _ _n_ fillcolor _ _B22222_ normal -_ transaction _label _ _nREDIS_MULTI_ transaction -_ dirty_cas _label _ _nREDIS_DIRTY_CAS_]: /images/20220115/6e1515ccce634e5d95f8d0a16832e4fe.png
[ACID]: http://en.wikipedia.org/wiki/ACID
[https_redisbook.readthedocs.io_en_latest_feature_transaction.html]: https://redisbook.readthedocs.io/en/latest/feature/transaction.html