神仙打架，事务 vs 管道，何时使用何种？

灰太狼 2024-02-21 11:31 32阅读 0赞

![在这里插入图片描述][569c93ff22054aa0becb19f681aec5cf.gif_pic_center]

#### 目录 ####

*   *   *  1、订单支付需求
         *  2、数据一致性要求
         *  3、高并发支付
     *  一、Redis事务
     *   *  1、什么是Redis事务
         *   *  （1）事务概述
             *  （2）Redis的事务特性
         *  2、使用Redis事务
         *   *  （1）开始和提交事务
             *  （2）事务命令
             *  （3）事务示例
     *  二、Redis管道
     *   *  1、什么是Redis管道
         *   *  （1）管道概述
             *  （2）Redis的管道特性
         *  2、使用Redis管道
         *   *  （1）管道命令
             *  （2）管道优化性能
     *  三、事务 vs 管道：何时使用何种
     *   *  1、事务的适用场景
         *   *  （1）强一致性操作
             *  （2）原子性要求高
         *  2、管道的适用场景
         *   *  （1）批量操作
             *  （2）吞吐量要求高
     *  四、案例研究：保证订单支付的数据一致性与性能优化
     *   *  1、场景描述
         *   *  （1）订单支付需求
             *  （2）数据一致性要求
             *  （3）高并发支付
         *  2、使用Redis事务解决数据一致性问题
         *   *  （1）事务实现订单支付
             *  （2）事务的一致性保证
         *  3、使用Redis管道优化支付性能
         *   *  （1）管道批量支付
             *  （2）管道的性能提升
     *  五、事务和管道的限制与注意事项
     *   *  1、事务的限制
         *   *  （1）WATCH命令
             *  （2）乐观锁
         *  2、管道的注意事项
         *   *  （1）不支持事务
             *  （2）慎用管道
     *  六、总结
     *  Redis一网打尽

大家好，我是哪吒。

在前几篇文章中，提到了[Redis实现排行榜][Redis]、[Redis数据缓存策略][Redis 1]，让我们对Redis有了进一步的认识，今天继续进修，了解一下**Redis在下单时是如何保证数据一致性的？**

例如，在高并发访问下，可能会有多个请求同时读取同一份缓存数据，然后进行写操作，这就容易产生数据竞争的情况。同时，读写操作并不是原子性操作，可能在读取数据的时候，缓存已经被其他请求更新掉，从而导致数据不一致。

为了解决Redis缓存的数据一致性问题，我们需要做到以下两点：

1.  **保证所有请求都是读取最新的数据**；
2.  **保证所有更新操作都是互斥的并且按照请求的顺序执行**。

![在这里插入图片描述][6f320cbe2d7b4dd9bf9ed21251143775.png_pic_center]

在一个在线商城系统中，面临一个重要的问题：如何在订单支付过程中保证数据的一致性，并且如何优化支付操作的性能。

#### 1、订单支付需求 ####

在用户下单后，需要执行订单支付操作，确保支付和订单状态的一致性。

#### 2、数据一致性要求 ####

支付成功后，必须将订单状态更新为已支付，以保持数据的一致性。

#### 3、高并发支付 ####

在高并发的情况下，需要确保订单支付的性能和数据一致性。

为了解决以上问题，我们可以使用Redis提供的事务和管道机制。

### 一、Redis事务 ###

#### 1、什么是Redis事务 ####

![在这里插入图片描述][6ac8cb2ecb194346a46e6ae8f2688660.png_pic_center]

> 在Redis中，事务是一组命令的集合，可以在一个单独的流程中执行，以保证这些命令的原子性、一致性、隔离性和持久性。

##### （1）事务概述 #####

Redis事务由以下四个关键命令进行管理：

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>MULTI</td> 
   <td>开启事务，标记事务块的开始。</td> 
  </tr> 
  <tr> 
   <td>EXEC</td> 
   <td>执行事务中的所有命令。</td> 
  </tr> 
  <tr> 
   <td>DISCARD</td> 
   <td>取消事务，放弃所有已经入队的命令。</td> 
  </tr> 
  <tr> 
   <td>WATCH</td> 
   <td>监视一个或多个键，用于乐观锁。</td> 
  </tr> 
 </tbody> 
</table>

##### （2）Redis的事务特性 #####

Redis事务具有以下关键特性：

<table> 
 <thead> 
  <tr> 
   <th>事务特性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>原子性</td> 
   <td>事务中的所有命令要么全部执行，要么全部不执行。这确保了在事务执行期间，不会发生部分命令执行成功而部分命令执行失败的情况。</td> 
  </tr> 
  <tr> 
   <td>一致性</td> 
   <td>事务中的命令会按照被添加的顺序执行，不会被其他客户端的命令打断。这保证了事务中的操作按照期望的顺序执行，不会受到并发操作的影响。</td> 
  </tr> 
  <tr> 
   <td>隔离性</td> 
   <td>在事务执行期间，事务会被隔离，不会受到其他事务的影响。即使有其他并发事务在执行，事务中的操作也不会被其他事务看到，直到事务被执行提交。</td> 
  </tr> 
  <tr> 
   <td>持久性</td> 
   <td>事务执行结束后对数据库的修改将被持久化到磁盘上。这确保了事务中的操作不会因为系统故障而丢失，从而保证了数据的持久性。</td> 
  </tr> 
 </tbody> 
</table>

以上是Redis事务的基本概念和特性，它们保证了在Redis中执行的事务是可靠的、具备一致性的操作集合。

![在这里插入图片描述][fe5a18d4824a4a13ae26e9d372946ec0.png_pic_center]

上图形表示了Redis事务的关键特性之间的相互关系。这些特性相互支持，共同确保了Redis事务的可靠性和一致性。

1.  **原子性**保证了事务中的操作要么全部成功，要么全部失败。
2.  **一致性**保证了事务中的操作按照特定的顺序执行，不会受到其他操作的干扰。
3.  **隔离性**确保了事务在执行期间与其他事务相互隔离，互不干扰。
4.  **持久性**确保了事务执行后的修改会被持久保存，不会因系统故障而丢失。这些特性一起构成了Redis事务的可靠性和稳定性的基础。

#### 2、使用Redis事务 ####

##### （1）开始和提交事务 #####

在Redis中，使用事务需要遵循以下步骤：

1.  使用`MULTI`命令开启事务。
2.  执行需要在事务中执行的命令。
3.  使用`EXEC`命令提交事务，执行事务中的所有命令。

下面是一个使用Java代码示例的详细步骤：

// 创建与Redis服务器的连接
    Jedis jedis = new Jedis("localhost", 6379);
    
    // 开启事务
    Transaction transaction = jedis.multi();
    
    // 执行事务中的命令
    transaction.set("key1", "value1");
    transaction.set("key2", "value2");
    
    // 提交事务并获取执行结果
    List<Object> results = transaction.exec();

在上面的示例中，`transaction.set("key1", "value1")` 和 `transaction.set("key2", "value2")` 这两个命令会被添加到事务队列中，当`transaction.exec()`被调用时，事务中的所有命令会被一起执行。如果在`MULTI`和`EXEC`之间有错误发生，事务会被取消，命令不会执行。

##### （2）事务命令 #####

在事务中，您可以使用常规的Redis命令，例如`SET`、`GET`、`HSET`、`ZADD`等等。这些命令会被添加到事务队列中，直到执行`EXEC`命令。

##### （3）事务示例 #####

以下是使用Java代码示例来演示在事务中执行常见的Redis命令：

import redis.clients.jedis.Jedis;
    import redis.clients.jedis.Transaction;
    
    public class RedisTransactionCommandsExample {
        
        public static void main(String[] args) {
        
            Jedis jedis = new Jedis("localhost", 6379);
    
            // 开启事务
            Transaction transaction = jedis.multi();
    
            // 执行事务中的命令
            transaction.set("name", "Alice");
            transaction.hset("user:1", "name", "Bob");
            transaction.zadd("scores", 100, "Alice");
            transaction.zadd("scores", 200, "Bob");
    
            // 提交事务并获取执行结果
            List<Object> results = transaction.exec();
    
            // 打印执行结果
            for (Object result : results) {
        
                System.out.println("Result: " + result);
            }
    
            // 关闭连接
            jedis.close();
        }
    }

在上述示例中，使用了`SET`、`HSET`和`ZADD`命令，这些命令被添加到了事务队列中。当执行`transaction.exec()`时，事务中的所有命令会被一起执行。这里的示例是简单的演示，您可以根据需要添加更多的命令来构建更复杂的事务。

![ed9a13f3853ce2239d340b7c66bf6b62.png][]

### 二、Redis管道 ###

#### 1、什么是Redis管道 ####

> Redis管道（Pipeline）是一种优化Redis操作的技术，它允许在单次通信中发送多个命令到Redis服务器，从而显著减少了通信开销，提高了性能。

管道可以将多个命令一次性发送给服务器，而不需要等待每个命令的响应，这使得Redis能够更高效地处理批量操作和大规模数据的读写。

下图展示了Redis管道的工作原理：

![在这里插入图片描述][9aa5a7322f854ccfb89f96571fa6d725.png_pic_center]

在上图中，客户端（Client）向Redis服务器（Server）发送多个命令，每个命令用`Command 1`、`Command 2`等表示。这些命令被一次性发送到服务器，而不需要等待每个命令的响应。服务器在执行所有命令后，一次性将结果响应给客户端。同时说明了Redis管道的工作方式：通过将多个命令打包成一次通信，减少了每个命令的通信开销，提高了系统的性能。

使用Redis管道时，客户端通过创建一个管道对象，将多个命令添加到管道中，然后一次性执行管道中的命令。最后，客户端可以收集所有命令的执行结果。

##### （1）管道概述 #####

在Redis中，管道是通过以下命令进行管理：

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>PIPELINE</code></td> 
   <td>开启管道模式，用于一次性发送多个命令。</td> 
  </tr> 
  <tr> 
   <td><code>MULTI</code></td> 
   <td>开启事务模式，用于在管道中执行一系列命令。</td> 
  </tr> 
  <tr> 
   <td><code>EXEC</code></td> 
   <td>提交管道中的事务，执行并返回结果。</td> 
  </tr> 
 </tbody> 
</table>

使用管道，您可以将多个命令一次性发送给服务器，然后通过一次通信获得所有命令的执行结果，从而减少了每个命令的通信开销，提高了系统的性能。

##### （2）Redis的管道特性 #####

使用Redis管道可以获得以下优势：

*  **减少通信开销：** 在普通的命令传输中，每个命令都需要来回的网络通信，而管道可以将多个命令打包一次性发送给服务器，从而大大减少了通信开销。这对于网络延迟较高的场景尤为重要，有效提高了性能。
 *  **提高吞吐量：** 管道允许在一次通信中执行多个命令，从而在单位时间内处理更多的命令。这对于需要处理大量命令的场景，如批量数据处理、并发请求处理等，能够有效提高Redis的吞吐量和响应能力。

#### 2、使用Redis管道 ####

##### （1）管道命令 #####

以下是一个实际案例，展示如何使用Redis管道来执行多个命令并提高性能：

import redis.clients.jedis.Jedis;
    import redis.clients.jedis.Pipeline;
    import java.util.List;
    
    public class RedisPipelineExample {
        
        public static void main(String[] args) {
        
            Jedis jedis = new Jedis("localhost", 6379);
    
            // 创建管道
            Pipeline pipeline = jedis.pipelined();
    
            // 向管道中添加命令
            for (int i = 0; i < 10000; i++) {
        
                pipeline.set("key" + i, "value" + i);
            }
    
            // 执行管道中的命令
            List<Object> results = pipeline.syncAndReturnAll();
    
            // 关闭连接
            jedis.close();
        }
    }

在上述案例中，使用了一个循环来向管道中添加10000个`SET`命令。通过使用管道，可以在一次通信中将所有命令发送到服务器，而不是逐个发送，从而减少了通信开销，提高了性能。

##### （2）管道优化性能 #####

使用Redis管道可以提高性能，特别是在需要批量处理多个命令的情况下。管道的原理是一次性将多个命令发送给服务器，然后一次性获取结果，这减少了通信的往返次数，从而显著提高了吞吐量。

然而，需要注意以下几点：

*  管道不支持事务，不能保证多个命令的原子性执行。
 *  使用管道时，命令的执行顺序可能与添加顺序不一致，这需要根据业务需求进行考虑。
 *  管道并非在所有场景下都能带来性能提升，需要根据实际情况进行评估。

通过合理使用管道，可以最大限度地发挥Redis在高性能数据处理中的优势。

![在这里插入图片描述][b80d9298653446f2b5f932695e959a0c.jpeg_pic_center]

### 三、事务 vs 管道：何时使用何种 ###

#### 1、事务的适用场景 ####

事务在某些场景下可以保证原子性和一致性的操作，特别适用于强一致性要求的业务操作，例如支付操作。

##### （1）强一致性操作 #####

事务是一种适用于需要强一致性操作的机制。当多个命令需要在一个操作序列中原子性地执行时，事务可以确保这些命令**要么全部执行，要么全部不执行**，以保持数据的一致性。

在以下示例中，模拟一个银行转账操作，其中需要同时扣减一个账户的余额并增加另一个账户的余额：

Jedis jedis = new Jedis("localhost", 6379);
    
    // 开启事务
    Transaction transaction = jedis.multi();
    
    // 扣减账户1余额
    transaction.decrBy("account1", 100);
    
    // 增加账户2余额
    transaction.incrBy("account2", 100);
    
    // 提交事务并获取执行结果
    List<Object> results = transaction.exec();
    
    // 关闭连接
    jedis.close();

##### （2）原子性要求高 #####

当业务要求多个操作要么全部成功，要么全部失败时，事务是更好的选择。事务确保了事务中的一系列命令以原子操作方式执行，从而维护了数据的一致性。

#### 2、管道的适用场景 ####

管道适用于需要批量操作和吞吐量要求较高的场景。通过一次性发送多个命令到服务器，可以减少通信开销，提高性能。

##### （1）批量操作 #####

使用管道可以有效地执行批量操作。例如，当您需要向数据库中添加大量数据时，使用管道可以减少每个命令的通信成本，从而大大提高操作的效率。

以下示例演示了如何使用管道进行批量设置操作：

import redis.clients.jedis.Jedis;
    import redis.clients.jedis.Pipeline;
    import java.util.List;
    
    public class RedisPipelineBatchExample {
        
        public static void main(String[] args) {
        
            Jedis jedis = new Jedis("localhost", 6379);
            Pipeline pipeline = jedis.pipelined();
    
            // 向管道中添加一批设置操作
            for (int i = 0; i < 1000; i++) {
        
                pipeline.set("key" + i, "value" + i);
            }
    
            // 执行管道中的命令
            List<Object> results = pipeline.syncAndReturnAll();
    
            // 关闭连接
            jedis.close();
        }
    }

##### （2）吞吐量要求高 #####

在需要高吞吐量的场景下，管道可以显著提升性能。当多个命令需要在短时间内执行时，使用管道可以将这些命令打包发送，减少了通信的往返次数。

使用管道来进行大规模数据处理时，尤其可以在高负载的情况下提高系统的处理能力。

![在这里插入图片描述][f72656e3e4ca46e38d1b204558679f94.png_pic_center]

### 四、案例研究：保证订单支付的数据一致性与性能优化 ###

#### 1、场景描述 ####

在一个在线商城系统中，面临一个重要的问题：如何在订单支付过程中保证数据的一致性，并且如何优化支付操作的性能。

##### （1）订单支付需求 #####

在用户下单后，需要执行订单支付操作，确保支付和订单状态的一致性。

##### （2）数据一致性要求 #####

支付成功后，必须将订单状态更新为已支付，以保持数据的一致性。

##### （3）高并发支付 #####

在高并发的情况下，需要确保订单支付的性能和数据一致性。

#### 2、使用Redis事务解决数据一致性问题 ####

##### （1）事务实现订单支付 #####

Jedis jedis = new Jedis("localhost", 6379);
    Transaction transaction = jedis.multi();
    
    // 扣除用户余额
    transaction.decrBy("user:balance:1", orderAmount);
    
    // 更新订单状态为已支付
    transaction.hset("order:1", "status", "paid");
    
    List<Object> results = transaction.exec();

以上示例中，使用了Redis事务来确保在一个操作序列中，用户余额的扣除和订单状态的更新同时发生。如果事务中的任何一步操作失败，整个事务都会被回滚，保证了数据的一致性。

##### （2）事务的一致性保证 #####

使用事务可以保证用户余额和订单状态的一致性，要么同时成功，要么同时失败。这样，可以确保支付和订单状态的正确性，避免了潜在的数据不一致问题。

#### 3、使用Redis管道优化支付性能 ####

##### （1）管道批量支付 #####

Jedis jedis = new Jedis("localhost", 6379);
    Pipeline pipeline = jedis.pipelined();
    
    for (Order order : orders) {
        
        pipeline.decrBy("user:balance:" + order.getUserId(), order.getAmount());
        pipeline.hset("order:" + order.getId(), "status", "paid");
    }
    
    List<Object> results = pipeline.syncAndReturnAll();

在这个示例中，使用了Redis管道来批量处理多个订单的支付。通过将多个命令一次性发送给服务器，可以减少通信开销，从而显著提高支付操作的性能。

##### （2）管道的性能提升 #####

通过使用管道，可以将多个支付操作打包在一次通信中进行，减少了通信往返次数，从而提高了支付的性能。

尤其在高并发支付的场景下，管道可以显著减少服务器负载，提高系统的响应能力。

![在这里插入图片描述][a515f04ec2e444d09047c89de0f883cb.png_pic_center]

### 五、事务和管道的限制与注意事项 ###

#### 1、事务的限制 ####

事务在使用过程中需要注意以下限制，其中包括**WATCH命令和乐观锁**的使用。

##### （1）WATCH命令 #####

在事务中使用WATCH命令可以监视一个或多个键，如果被监视的键在事务执行过程中被其他客户端修改，事务会被中断。这是为了保证事务的一致性和避免竞态条件。

正面例子：

Jedis jedis = new Jedis("localhost", 6379);
    Transaction transaction = jedis.multi();
    
    // 监视键"balance"
    transaction.watch("balance");
    
    // ... 在此期间可能有其他客户端修改了"balance"键的值 ...
    
    // 执行事务
    List<Object> results = transaction.exec();

反面例子：

Jedis jedis = new Jedis("localhost", 6379);
    Transaction transaction = jedis.multi();
    
    // 监视键"balance"
    transaction.watch("balance");
    
    // ... 在此期间其他客户端修改了"balance"键的值 ...
    
    // 尝试执行事务，但由于"balance"键被修改，事务会被中断
    List<Object> results = transaction.exec();

##### （2）乐观锁 #####

在处理并发更新时，可以使用乐观锁的方式。通过使用版本号或时间戳等机制，在执行命令前先检查数据是否被其他客户端修改过，从而避免并发冲突。

正面例子：

Jedis jedis = new Jedis("localhost", 6379);
    
    // 获取当前版本号
    long currentVersion = Long.parseLong(jedis.get("version"));
    
    // 更新数据前检查版本号
    if (currentVersion == Long.parseLong(jedis.get("version"))) {
        
        Transaction transaction = jedis.multi();
        transaction.set("data", "new value");
        transaction.incr("version");
        List<Object> results = transaction.exec();
    } else {
        
        // 数据已被其他客户端修改，需要处理冲突
    }

#### 2、管道的注意事项 ####

使用管道时需要注意以下事项，包括管道的串行性和慎重使用。

##### （1）不支持事务 #####

管道不支持事务，因此无法通过管道实现事务的原子性和一致性。如果需要事务支持，应该使用Redis的事务机制。

##### （2）慎用管道 #####

管道虽然可以提高性能，但并不是在所有场景下都能带来性能提升。在某些情况下，由于管道的串行性，某些命令可能会阻塞其他命令的执行，反而降低了性能。

正面例子：

Jedis jedis = new Jedis("localhost", 6379);
    Pipeline pipeline = jedis.pipelined();
    
    for (int i = 0; i < 1000; i++) {
        
        pipeline.set("key" + i, "value" + i);
    }
    
    // 执行管道中的命令并获取结果
    List<Object> results = pipeline.syncAndReturnAll();

反面例子：

Jedis jedis = new Jedis("localhost", 6379);
    Pipeline pipeline = jedis.pipelined();
    
    for (int i = 0; i < 1000; i++) {
        
        // 注意：此处执行了耗时的命令，可能阻塞其他命令的执行
        pipeline.get("key" + i);
    }
    
    // 执行管道中的命令并获取结果
    List<Object> results = pipeline.syncAndReturnAll();

### 六、总结 ###

本篇博客深入探讨了Redis中的事务和管道机制，以及它们在保证数据一致性和优化性能方面的应用。

通过详细的讲解和代码示例，我们了解了事务和管道的基本概念、特性、使用方法以及适用场景。以下是本篇博客的主要内容总结：

在**Redis事务**部分，我们了解了事务的概念和特性。事务可以确保一系列命令的原子性、一致性、隔离性和持久性。

通过MULTI、EXEC、DISCARD和WATCH命令，我们可以管理事务的开始、提交、回滚以及监视键变化。事务适用于需要保证原子性和一致性的操作，特别是在强一致性要求的场景下。

在**Redis管道**部分，我们深入了解了管道的概念和优势。**管道允许一次性发送多个命令到服务器，减少通信开销，提高性能。**

通过PIPELINE、MULTI和EXEC命令，我们可以创建管道、添加命令，并执行管道中的命令。管道适用于批量操作和吞吐量要求较高的场景，可以显著提高Redis的性能。

在**事务 vs 管道：何时使用何种**部分，我们对比了事务和管道的适用场景。

1.  事务适用于保证强一致性操作和原子性要求高的场景;
2.  管道适用于批量操作和高吞吐量的场景。

通过示例，我们说明了如何根据业务需求选择合适的机制来满足一致性和性能的需求。

在**案例研究：保证订单支付的数据一致性与性能优化**部分，我们应用之前的知识解决了一个实际问题。我们展示了如何使用事务保证订单支付的数据一致性，同时如何使用管道优化支付操作的性能。这个案例充分体现了事务和管道在实际业务中的应用。

在**事务和管道的限制与注意事项**部分，我们指出了事务和管道的一些限制和注意事项。**事务受到WATCH命令和乐观锁的限制，而管道不支持事务，并且需要在使用时慎重考虑性能影响。**

通过本篇博客，我们详细探讨了Redis中的事务和管道机制，了解了它们如何在实际应用中保证数据一致性和优化性能。无论是强调一致性还是追求性能，都可以根据业务需求选择合适的机制来达到最佳效果。

### Redis一网打尽 ###

[兄弟，王者荣耀的段位排行榜是通过Redis实现的？][Redis]

[本地缓存、Redis数据缓存策略][Redis 1]

[2023年再不会Redis，就要被淘汰了][2023_Redis]

[图解Redis，谈谈Redis的持久化，RDB快照与AOF日志][Redis_Redis_RDB_AOF]

[Redis单线程还是多线程？IO多路复用原理][Redis_IO]

[Redis集群的最大槽数为什么是16384个？][Redis_16384]

[Redis缓存穿透、击穿、雪崩到底是个啥？7张图告诉你][Redis_7]

[Redis分布式锁的实现方式][Redis 2]

[Redis分布式缓存、秒杀][Redis 3]

[Redis布隆过滤器的原理和应用场景，解决缓存穿透][Redis 4]

[569c93ff22054aa0becb19f681aec5cf.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/d752e65c9b224c18ae0053f0ae743955.png
[Redis]: https://blog.csdn.net/guorui_java/article/details/132529948
[Redis 1]: https://blog.csdn.net/guorui_java/article/details/132666743
[6f320cbe2d7b4dd9bf9ed21251143775.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/1ae0ada09c804c01a812f78d2a22413f.png
[6ac8cb2ecb194346a46e6ae8f2688660.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/08c983f50faa44ca9cc834908fcc48fe.png
[fe5a18d4824a4a13ae26e9d372946ec0.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/08fb60842eaa48929a81d6fb0f9ed3f4.png
[ed9a13f3853ce2239d340b7c66bf6b62.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/7b69d359355e4904989fe200865b8261.png
[9aa5a7322f854ccfb89f96571fa6d725.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/7e64defcf38c44c4af6055201f1391a7.png
[b80d9298653446f2b5f932695e959a0c.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/b25857861a4743a5b9a4a9a877d4faae.png
[f72656e3e4ca46e38d1b204558679f94.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/0839af7a342b4eb59edeb9c5cbf75268.png
[a515f04ec2e444d09047c89de0f883cb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/4543553a002e4225ba1cc51f9d510511.png
[2023_Redis]: https://blog.csdn.net/guorui_java/article/details/129292178
[Redis_Redis_RDB_AOF]: https://blog.csdn.net/guorui_java/article/details/129392856
[Redis_IO]: https://blog.csdn.net/guorui_java/article/details/129633029
[Redis_16384]: https://blog.csdn.net/guorui_java/article/details/129889788
[Redis_7]: https://blog.csdn.net/guorui_java/article/details/127714488
[Redis 2]: https://blog.csdn.net/guorui_java/article/details/127818975
[Redis 3]: https://blog.csdn.net/guorui_java/article/details/127950340
[Redis 4]: https://blog.csdn.net/guorui_java/article/details/130038255