事务隔离：从读未提交到串行化的爱情观

硅谷神农
86 阅读7分钟

事务隔离：从读未提交到串行化的爱情观

如果把数据库事务比作一场恋爱，那么隔离级别就是情侣之间相处模式的约定。从“开放式关系”到“绝对忠诚”，不同的隔离级别，对应着不同的“甜蜜”与“代价”。

1. 读未提交（Read Uncommitted）：开放式关系

  • 恋爱观：我的眼里可以有别人，你的眼里也可以有别人，互不干涉，自由奔放。
  • 技术解读：一个事务可以读取到另一个事务尚未提交的数据，就像情侣之间毫无隐私，对方的“小秘密”尽收眼底。
  • 问题：脏读（Dirty Read）。就像你看到了对方的“暧昧短信”，但对方可能最终“撤回”了。

代码示例（Java + MySQL）：

// 假设使用 JDBC 连接 MySQL，并设置隔离级别为 READ_UNCOMMITTED
import java.sql.*;

public class ReadUncommittedDemo {

    public static void main(String[] args) throws Exception {
        String url = "jdbc:mysql://localhost:3306/testdb?useSSL=false";
        String user = "root";
        String password = "your_password";

        // 线程1：转账事务（未提交）
        Thread thread1 = new Thread(() -> {
            try (Connection conn = DriverManager.getConnection(url, user, password)) {
                conn.setAutoCommit(false);
                conn.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);

                PreparedStatement stmt = conn.prepareStatement("UPDATE account SET balance = balance - 100 WHERE id = 1");
                stmt.executeUpdate();

                System.out.println("线程1：转账100元（未提交）");

                Thread.sleep(5000); // 模拟耗时操作

                // conn.rollback(); // 假设这里回滚了
                 conn.commit();
                System.out.println("线程1：事务回滚/提交");

            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        // 线程2：查询余额
        Thread thread2 = new Thread(() -> {
            try (Connection conn = DriverManager.getConnection(url, user, password)) {
                conn.setAutoCommit(false);
                conn.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);

                PreparedStatement stmt = conn.prepareStatement("SELECT balance FROM account WHERE id = 1");
                ResultSet rs = stmt.executeQuery();

                if (rs.next()) {
                    int balance = rs.getInt("balance");
                    System.out.println("线程2：查询到余额：" + balance); // 可能读到未提交的余额
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        thread1.start();
        Thread.sleep(1000); // 让线程1先执行
        thread2.start();
    }
}

可能的结果：

  • 如果线程1在线程2查询之后提交，线程2读到的是转账后的余额。
  • 如果线程1在线程2查询之后回滚，线程2读到的是一个“幻影”余额，即脏读。

2. 读已提交（Read Committed）：保持基本尊重

  • 恋爱观：我可以看你的手机，但你发完的消息我才能看，不能偷看你正在编辑的内容。
  • 技术解读：一个事务只能读取到另一个事务已经提交的数据，避免了脏读，但可能出现不可重复读（Non-Repeatable Read）。
  • 问题：不可重复读。就像你第一次看对方手机，看到一条消息，过一会儿再看，发现消息不见了（对方删除了）。

代码示例（Java + MySQL）：

// 设置隔离级别为 READ_COMMITTED，其余代码与上例类似，只需修改 setTransactionIsolation 方法
conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

流程图：

sequenceDiagram
    participant Thread1 as 转账事务
    participant Thread2 as 查询事务
    participant DB as 数据库

    Thread1->>DB: 开始事务
    Thread1->>DB: UPDATE account SET balance = balance - 100 WHERE id = 1
    Thread2->>DB: 开始事务
    Thread2->>DB: SELECT balance FROM account WHERE id = 1
    DB-->>Thread2: 返回旧余额（Read Committed）
    Thread1->>DB: COMMIT
    Thread2->>DB: SELECT balance FROM account WHERE id = 1
    DB-->>Thread2: 返回新余额（不可重复读）
    Thread2->>DB: COMMIT

3. 可重复读（Repeatable Read）：忠诚的誓言

  • 恋爱观：在我俩的恋爱期间，你看我的手机，每次看到的内容都应该一样，我不会偷偷删除或修改。
  • 技术解读：一个事务在执行期间，多次读取同一数据，会得到一致的结果，即使其他事务修改了该数据并提交。这是MySQL的默认隔离级别。
  • 问题：幻读（Phantom Read）。虽然你看我的手机内容不变，但我可以偷偷加新的联系人，你下次看的时候，会发现“多出来”一些人。

代码示例（Java + MySQL）：

// 设置隔离级别为 REPEATABLE_READ，其余代码与上例类似
conn.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);

流程图：

sequenceDiagram
    participant Thread1 as 插入事务
    participant Thread2 as 查询事务
    participant DB as 数据库

    Thread2->>DB: 开始事务
    Thread2->>DB: SELECT * FROM account WHERE balance > 500
    DB-->>Thread2: 返回结果集1
    Thread1->>DB: 开始事务
    Thread1->>DB: INSERT INTO account (id, balance) VALUES (3, 600)
    Thread1->>DB: COMMIT
    Thread2->>DB: SELECT * FROM account WHERE balance > 500
    DB-->>Thread2: 返回结果集1（可重复读，但可能有幻读）
    Thread2->>DB: COMMIT

4. 串行化（Serializable）：绝对的占有欲

  • 恋爱观：在我俩的恋爱期间，你的手机只能有我一个联系人，不能有任何其他人，也不能有任何变化。
  • 技术解读：所有事务串行执行，完全避免了脏读、不可重复读和幻读，但性能最差。
  • 实现：通过锁表或锁行实现。

代码示例（Java + MySQL）：

// 设置隔离级别为 SERIALIZABLE，其余代码与上例类似
conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);

常见面试题

  1. 什么是脏读、不可重复读和幻读？请分别举例说明。

    • 脏读：事务A读取了事务B未提交的数据。例如，事务B修改了余额但未提交，事务A读取到了这个修改后的余额，但事务B最终回滚了，导致事务A读取的数据无效。
    • 不可重复读：事务A多次读取同一数据，但在事务A执行期间，事务B修改并提交了该数据，导致事务A多次读取的结果不一致。例如，事务A第一次读取余额为100，事务B修改余额为200并提交，事务A再次读取余额变为200。
    • 幻读：事务A多次读取同一范围的数据，但在事务A执行期间，事务B插入或删除了符合该范围的数据并提交，导致事务A多次读取的结果集数量不一致。例如，事务A第一次读取余额大于500的账户有2个，事务B插入了一个余额为600的账户并提交，事务A再次读取发现有3个账户。

  2. MySQL的默认隔离级别是什么？它是如何实现的？

    • MySQL的默认隔离级别是可重复读（Repeatable Read）。
    • MySQL通过**MVCC（多版本并发控制）**来实现可重复读。MVCC为每个事务创建一个快照，事务在快照上读取数据，即使其他事务修改了数据，当前事务也不会看到这些修改。

  3. MVCC是如何工作的？

    • MVCC通过为每行数据维护多个版本来实现。每个版本都有一个创建版本号和一个删除版本号（如果该行未被删除，则删除版本号为空）。
    • 当事务开始时，它会获取一个事务ID。
    • 当事务读取数据时，它会根据事务ID和数据的版本号来判断哪些版本的数据对当前事务可见。
    • 具体规则如下：
      • 如果数据的创建版本号小于或等于当前事务ID，且删除版本号为空或大于当前事务ID，则该版本的数据对当前事务可见。
      • 否则，该版本的数据对当前事务不可见。

  4. 可重复读隔离级别能完全避免幻读吗？

    • 在标准的SQL定义中，可重复读是不能完全避免幻读的。
    • 但是，MySQL的InnoDB存储引擎通过间隙锁（Gap Lock）和Next-Key Lock在一定程度上解决了幻读问题。
      • 间隙锁：锁定一个范围，但不包含记录本身。
      • Next-Key Lock：锁定一个范围，并且锁定记录本身。
    • 通过这些锁机制，InnoDB可以防止其他事务在当前事务读取的范围内插入新的数据，从而减少了幻读的可能性。但是，在某些特定情况下，幻读仍然可能发生。

  5. 如何选择合适的隔离级别？

    • 选择隔离级别需要权衡数据一致性和并发性能。
    • 一般来说，对于大多数应用，**读已提交（Read Committed）**隔离级别已经足够，它可以避免脏读，同时提供较好的并发性能。
    • 如果应用对数据一致性要求非常高，例如银行系统，可能需要使用**可重复读（Repeatable Read）甚至串行化（Serializable）**隔离级别。
    • **读未提交（Read Uncommitted）**隔离级别通常不推荐使用，因为它可能导致脏读。

  6. 在代码中如何设置事务的隔离级别？

    • 可以使用 Connection 对象的 setTransactionIsolation() 方法来设置事务的隔离级别。例如：
    connection.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

  7. 除了隔离级别，还有哪些因素会影响事务的并发性？

    • 锁的粒度（行锁、表锁、页锁）
    • 锁的类型（共享锁、排他锁）
    • 死锁的检测和处理机制
    • 数据库的配置参数（如锁超时时间）

  8. 什么是两阶段提交（2PC）？它与事务隔离级别有什么关系？

    • 两阶段提交（2PC）是一种分布式事务协议，用于保证在分布式系统中多个节点上的操作要么全部成功，要么全部失败。
    • 2PC与事务隔离级别是两个不同的概念。
      • 隔离级别是数据库内部的概念，用于控制并发事务之间的可见性。
      • 2PC是分布式系统的概念，用于协调多个数据库节点之间的事务。
    • 在使用2PC时，每个参与的数据库节点仍然需要设置自己的隔离级别来处理本地事务的并发。
avatar
文章
阅读
粉丝