【Redis 探秘】带你深入学习 Redis 事务处理机制

👉博主介绍： 博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主

⛪️ 个人社区：个人社区
💞 个人主页：个人主页
🙉 专栏地址： ✅ Java 中级
🙉八股文专题：剑指大厂，手撕 Java 八股文

1. Redis 的事务处理机制如何实现？

Redis 提供了一种简单的事务处理机制，允许用户一次执行多个命令，这些命令会被作为一个整体来执行。Redis 的事务通过 MULTI、EXEC、DISCARD 和 WATCH 命令来实现。下面是这些命令的基本用法和功能：

• MULTI：标记事务的开始。从这个命令之后，Redis 会将所有发送给服务器的命令放入队列中，而不是立即执行它们。
• EXEC：执行所有已排队的命令。当客户端调用 EXEC 时，Redis 会按顺序执行所有先前排队的命令，并将结果作为一个批量响应返回给客户端。
• DISCARD：取消事务，清空事务队列。如果在执行 EXEC 之前调用了 DISCARD，那么所有排队的命令都会被丢弃，事务被取消。
• WATCH：监视一个或多个键，以检查它们在事务执行前是否有被修改。如果在 WATCH 之后有其他客户端修改了被监视的键，那么在 EXEC 执行时，整个事务将会失败（即不会执行任何命令）。这样可以实现乐观锁的效果。

2. Java 案例讲解 Redis 事务处理机制

下面是一个使用 Jedis（一个流行的 Redis Java 客户端）来演示 Redis 事务处理的简单例子。

添加 Jedis 依赖

如果你使用 Maven，可以在你的 pom.xml 文件中添加如下依赖：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.0.1</version>
</dependency>

java 代码

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

public class RedisTransactionExample {

    public static void main(String[] args) {
        // 连接到本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");

        try {
            // 开始事务
            Transaction tx = jedis.multi();

            // 将多个命令放入事务队列
            tx.set("key1", "value1");
            tx.set("key2", "value2");
            tx.incr("counter");

            // 执行事务
            tx.exec();

            // 输出结果
            System.out.println("key1: " + jedis.get("key1"));
            System.out.println("key2: " + jedis.get("key2"));
            System.out.println("counter: " + jedis.get("counter"));

        } catch (Exception e) {
            // 如果出现异常，可以通过 discard 方法取消事务
            jedis.discard();
            e.printStackTrace();
        } finally {
            // 关闭连接
            jedis.close();
        }
    }
}

1. 连接到 Redis：首先创建一个 Jedis 实例来连接到本地的 Redis 服务。
2. 开始事务：调用 jedis.multi() 方法开始一个事务。
3. 添加命令到事务：使用事务对象 tx 来调用 Redis 命令，这些命令不会立即执行，而是被加入到事务队列中。
4. 执行事务：调用 tx.exec() 方法来执行事务中的所有命令。如果所有命令都成功执行，则返回每个命令的结果列表。
5. 异常处理：如果在事务执行过程中发生异常，可以通过调用 jedis.discard() 来取消事务。
6. 关闭连接：无论事务是否成功执行，都应该确保关闭与 Redis 的连接。

3. Redis 事务如何处理多个 Key?

在 Redis 中，事务可以处理多个键（Keys），并且这些键可以分布在不同的命令中。事务的主要特点是将多个命令作为一个整体来执行，这意味着在一个事务中，你可以对多个键进行操作，这些操作将按照顺序执行，并且要么全部成功，要么全部失败。

假设我们有一个场景，需要同时增加两个计数器的值，并设置一个键的过期时间。可以使用以下步骤来实现：

1. 开始事务：使用 MULTI 命令开始事务。
2. 添加命令：将需要执行的命令添加到事务队列中。
3. 执行事务：使用 EXEC 命令执行事务。

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

public class RedisMultipleKeyTransactionExample {

    public static void main(String[] args) {
        // 连接到本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");

        try {
            // 开始事务
            Transaction tx = jedis.multi();

            // 对多个键进行操作
            tx.incr("counter1");  // 增加 counter1 的值
            tx.incr("counter2");  // 增加 counter2 的值
            tx.setex("session_id", 3600, "user123");  // 设置 session_id 的过期时间为 1 小时

            // 执行事务
            tx.exec();

            // 输出结果
            System.out.println("counter1: " + jedis.get("counter1"));
            System.out.println("counter2: " + jedis.get("counter2"));
            System.out.println("session_id: " + jedis.get("session_id"));

        } catch (Exception e) {
            // 如果出现异常，可以通过 discard 方法取消事务
            jedis.discard();
            e.printStackTrace();
        } finally {
            // 关闭连接
            jedis.close();
        }
    }
}

在这个例子中，我们对 counter1 和 counter2 进行了 INCR 操作，并设置了 session_id 的过期时间。所有这些操作都被包含在一个事务中，确保它们作为一个整体来执行。

4. Redis 事务在并发场景下如何工作？

在并发场景下，Redis 事务的行为可以通过以下几个方面来理解：

1. 命令排队：当一个客户端进入事务模式后，所有发送的命令都会被排队，而不是立即执行。这意味着即使在事务模式下，其他客户端仍然可以继续执行命令，不受影响。

2. 原子性：当调用 EXEC 时，Redis 会按顺序执行事务队列中的所有命令。这些命令在一个单独的上下文中执行，不会被其他客户端的命令中断。因此，从客户端的角度来看，事务是原子的。

3. 乐观锁：Redis 提供了 WATCH 命令来实现乐观锁。在事务执行前，可以使用 WATCH 监视一个或多个键。如果在 WATCH 之后有其他客户端修改了被监视的键，那么在 EXEC 时，事务将被取消（即不会执行任何命令）。

假设我们有两个客户端，都试图在同一时间增加同一个计数器的值。我们使用 WATCH 来确保事务的一致性。

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

public class RedisConcurrentTransactionExample {

    public static void main(String[] args) {
        // 连接到本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");

        try {
            // 监视键
            jedis.watch("counter");

            // 获取当前值
            long currentValue = Long.parseLong(jedis.get("counter"));

            // 开始事务
            Transaction tx = jedis.multi();

            // 增加计数器的值
            tx.set("counter", String.valueOf(currentValue + 1));

            // 执行事务
            List<Object> results = tx.exec();

            if (results == null || results.isEmpty()) {
                System.out.println("事务被取消，因为被监视的键已被修改");
            } else {
                System.out.println("事务成功执行");
            }

        } catch (Exception e) {
            // 如果出现异常，可以通过 discard 方法取消事务
            jedis.discard();
            e.printStackTrace();
        } finally {
            // 关闭连接
            jedis.close();
        }
    }
}

• 多键操作：Redis 事务可以处理多个键，并将这些操作作为一个整体来执行。
• 并发场景：Redis 事务在并发场景下通过命令排队和乐观锁（WATCH）来确保事务的一致性和原子性。

精彩专栏推荐订阅：在下方专栏👇🏻
✅ 2023年华为OD机试真题（A卷&B卷）+ 面试指导
✅ 精选100套 Java 项目案例
✅ 面试需要避开的坑（活动）
✅ 你找不到的核心代码
✅ 带你手撕 Spring
✅ Java 初阶