MySQL存储引擎内部之：`InnoDB`的`锁`：`Record Lock`、`Gap Lock`、`Next-Key Lock`的底层实现。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

InnoDB 存储引擎内部之锁机制深度解析：Record Lock、Gap Lock、Next-Key Lock

各位同学，大家好！今天我们来深入探讨 MySQL InnoDB 存储引擎的锁机制，重点聚焦 Record Lock、Gap Lock 和 Next-Key Lock 这三种锁的底层实现。理解这些锁的工作原理对于编写高性能、高并发的数据库应用至关重要。

1. Record Lock：行记录锁

Record Lock，顾名思义，是对索引记录（index record）的锁定。在InnoDB中，只有通过索引才能访问数据行，所以Record Lock本质上是索引记录锁。

工作原理： 当事务需要修改或读取某一行数据时，InnoDB 会对该行数据对应的索引记录加锁。其他事务如果尝试修改或读取同一行数据（通过同一索引），将会被阻塞，直到持有锁的事务释放锁。
加锁方式： Record Lock 分为共享锁（S-lock）和排他锁（X-lock）。
- S-lock (Shared Lock)： 允许其他事务读取该行数据，但不允许修改。多个事务可以同时持有同一行数据的 S-lock。
- X-lock (Exclusive Lock)： 阻止其他事务读取或修改该行数据。只有一个事务可以持有某一行数据的 X-lock。
加锁场景：
- SELECT ... LOCK IN SHARE MODE：显式加 S-lock。
- SELECT ... FOR UPDATE：显式加 X-lock。
- UPDATE ... WHERE ...：隐式加 X-lock。
- DELETE ... WHERE ...：隐式加 X-lock。
- INSERT ... (唯一索引冲突时)：尝试加 X-lock，失败则报错。

示例代码 (Java + JDBC):

import java.sql.*;

public class RecordLockExample {

    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/testdb";
        String user = "root";
        String password = "password"; // 替换为你的密码

        try (Connection conn1 = DriverManager.getConnection(url, user, password);
             Connection conn2 = DriverManager.getConnection(url, user, password)) {

            conn1.setAutoCommit(false);
            conn2.setAutoCommit(false);

            // 事务 1: 使用 FOR UPDATE 加 X-lock
            try (PreparedStatement pstmt1 = conn1.prepareStatement("SELECT * FROM products WHERE id = 1 FOR UPDATE")) {
                ResultSet rs1 = pstmt1.executeQuery();
                if (rs1.next()) {
                    System.out.println("Transaction 1: Acquired X-lock on product id 1");

                    // 事务 2: 尝试读取并加 X-lock (会被阻塞)
                    try (PreparedStatement pstmt2 = conn2.prepareStatement("SELECT * FROM products WHERE id = 1 FOR UPDATE")) {
                        System.out.println("Transaction 2: Attempting to acquire X-lock on product id 1...");
                        ResultSet rs2 = pstmt2.executeQuery(); // 阻塞在此处
                        if (rs2.next()) {
                            System.out.println("Transaction 2: Acquired X-lock on product id 1");
                        }
                    } catch (SQLException e) {
                        System.err.println("Transaction 2: Error acquiring X-lock: " + e.getMessage());
                    }

                    // 事务 1: 提交事务，释放锁
                    conn1.commit();
                    System.out.println("Transaction 1: Committed and released X-lock");

                } else {
                    System.out.println("Transaction 1: Product id 1 not found.");
                    conn1.rollback();
                }
            } catch (SQLException e) {
                System.err.println("Transaction 1: Error acquiring X-lock: " + e.getMessage());
                conn1.rollback();
            }

        } catch (SQLException e) {
            System.err.println("Connection error: " + e.getMessage());
        }
    }
}

MySQL 表结构 (products):

CREATE TABLE products (
  id INT PRIMARY KEY,
  name VARCHAR(255),
  price DECIMAL(10, 2)
);

INSERT INTO products (id, name, price) VALUES (1, 'Product A', 10.00);

代码解释:

两个连接: 我们创建了两个数据库连接 conn1 和 conn2，模拟两个并发事务。
禁用自动提交: conn1.setAutoCommit(false) 和 conn2.setAutoCommit(false) 禁用了自动提交，使我们可以手动控制事务的提交和回滚。
事务 1: 使用 SELECT * FROM products WHERE id = 1 FOR UPDATE 语句，显式地对 products 表中 id = 1 的行加 X-lock。
事务 2: 也尝试使用 SELECT * FROM products WHERE id = 1 FOR UPDATE 语句对同一行加 X-lock。由于事务 1 已经持有该行的 X-lock，事务 2 会被阻塞，直到事务 1 提交或回滚。
提交事务 1: conn1.commit() 提交事务 1，释放 X-lock。
事务 2 解锁: 事务 1 释放锁后，事务 2 就可以获得 X-lock 并继续执行。

2. Gap Lock：间隙锁

Gap Lock 是 InnoDB 中一种特殊的锁，它锁定的是索引记录之间的间隙，而不是索引记录本身。

工作原理： Gap Lock 防止其他事务在某个间隙中插入新的记录，从而避免幻读（Phantom Read）。即使间隙中没有记录，Gap Lock 也能阻止插入操作。
加锁方式： Gap Lock 只有共享锁 (S-lock) 模式，多个事务可以同时持有同一个间隙的 Gap Lock。
加锁场景：
- 当使用范围查询条件，且没有使用唯一索引时，InnoDB 会对满足查询条件的间隙加 Gap Lock。
- 当使用 REPEATABLE READ 隔离级别时，InnoDB 也会使用 Gap Lock 来防止幻读。
作用范围： Gap Lock 的作用范围取决于索引的类型和查询条件。它可以锁定单个间隙，也可以锁定多个间隙，甚至锁定整个索引。

示例代码 (Java + JDBC):

import java.sql.*;

public class GapLockExample {

    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/testdb";
        String user = "root";
        String password = "password"; // 替换为你的密码

        try (Connection conn1 = DriverManager.getConnection(url, user, password);
             Connection conn2 = DriverManager.getConnection(url, user, password)) {

            conn1.setAutoCommit(false);
            conn2.setAutoCommit(false);

            // 事务 1: 使用范围查询加 Gap Lock
            try (PreparedStatement pstmt1 = conn1.prepareStatement("SELECT * FROM products WHERE id BETWEEN 2 AND 5 FOR UPDATE")) {
                ResultSet rs1 = pstmt1.executeQuery();
                System.out.println("Transaction 1: Acquired Gap Lock between id 2 and 5");

                // 事务 2: 尝试在 Gap 中插入数据 (会被阻塞)
                try (PreparedStatement pstmt2 = conn2.prepareStatement("INSERT INTO products (id, name, price) VALUES (3, 'Product C', 12.00)")) {
                    System.out.println("Transaction 2: Attempting to insert into Gap...");
                    pstmt2.executeUpdate(); // 阻塞在此处
                    System.out.println("Transaction 2: Inserted into Gap");
                } catch (SQLException e) {
                    System.err.println("Transaction 2: Error inserting into Gap: " + e.getMessage());
                }

                // 事务 1: 提交事务，释放锁
                conn1.commit();
                System.out.println("Transaction 1: Committed and released Gap Lock");

            } catch (SQLException e) {
                System.err.println("Transaction 1: Error acquiring Gap Lock: " + e.getMessage());
                conn1.rollback();
            }

        } catch (SQLException e) {
            System.err.println("Connection error: " + e.getMessage());
        }
    }
}

MySQL 表结构 (products):

CREATE TABLE products (
  id INT PRIMARY KEY,
  name VARCHAR(255),
  price DECIMAL(10, 2)
);

INSERT INTO products (id, name, price) VALUES (1, 'Product A', 10.00);
INSERT INTO products (id, name, price) VALUES (6, 'Product F', 15.00);

代码解释:

范围查询: 事务 1 使用 SELECT * FROM products WHERE id BETWEEN 2 AND 5 FOR UPDATE 语句进行范围查询。由于 id 是主键索引，InnoDB 会对 id 在 2 和 5 之间的间隙 (2, 5) 加 Gap Lock。注意，这里假设 id=2,3,4,5 的数据都不存在。如果其中某些存在，则会产生 Next-Key Lock。
尝试插入: 事务 2 尝试在间隙 (2, 5) 中插入一条新的记录 id = 3。由于事务 1 已经持有该间隙的 Gap Lock，事务 2 的插入操作会被阻塞。
提交事务 1: 事务 1 提交事务，释放 Gap Lock。
事务 2 解锁: 事务 1 释放锁后，事务 2 就可以插入数据并继续执行。

3. Next-Key Lock：临键锁

Next-Key Lock 是 Record Lock 和 Gap Lock 的组合，它锁定的是索引记录本身以及该索引记录之前的间隙。可以理解为 (gap, record] 左开右闭区间。

工作原理： Next-Key Lock 既能防止其他事务修改或读取索引记录，又能防止其他事务在该索引记录之前的间隙中插入新的记录，从而实现可重复读（REPEATABLE READ）隔离级别下的幻读防御。
加锁方式： Next-Key Lock 分为共享锁（S-lock）和排他锁（X-lock）。
- S-lock： 允许其他事务读取索引记录，但不允许修改或在间隙中插入。
- X-lock： 阻止其他事务读取、修改索引记录或在间隙中插入。
加锁场景：
- 当使用范围查询条件，且没有使用唯一索引时，InnoDB 会对满足查询条件的记录及其之前的间隙加 Next-Key Lock。
- 在 REPEATABLE READ 隔离级别下，InnoDB 默认使用 Next-Key Lock 来防止幻读。

示例代码 (Java + JDBC):

import java.sql.*;

public class NextKeyLockExample {

    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/testdb";
        String user = "root";
        String password = "password"; // 替换为你的密码

        try (Connection conn1 = DriverManager.getConnection(url, user, password);
             Connection conn2 = DriverManager.getConnection(url, user, password)) {

            conn1.setAutoCommit(false);
            conn2.setAutoCommit(false);

            // 事务 1: 使用范围查询加 Next-Key Lock
            try (PreparedStatement pstmt1 = conn1.prepareStatement("SELECT * FROM products WHERE id >= 2 AND id <= 3 FOR UPDATE")) {
                ResultSet rs1 = pstmt1.executeQuery();
                System.out.println("Transaction 1: Acquired Next-Key Lock for id >= 2 and <= 3");

                // 事务 2: 尝试在 Gap 中插入数据 (会被阻塞)
                try (PreparedStatement pstmt2 = conn2.prepareStatement("INSERT INTO products (id, name, price) VALUES (2, 'Product B', 11.00)")) {
                    System.out.println("Transaction 2: Attempting to insert into Gap before id 2...");
                    pstmt2.executeUpdate(); // 阻塞在此处
                    System.out.println("Transaction 2: Inserted into Gap");
                } catch (SQLException e) {
                    System.err.println("Transaction 2: Error inserting into Gap: " + e.getMessage());
                }

                // 事务 2: 尝试修改 id = 3 的记录 (会被阻塞)
                try (PreparedStatement pstmt3 = conn2.prepareStatement("UPDATE products SET price = 13.00 WHERE id = 3")) {
                    System.out.println("Transaction 2: Attempting to update id 3...");
                    pstmt3.executeUpdate(); // 阻塞在此处
                    System.out.println("Transaction 2: Updated id 3");
                } catch (SQLException e) {
                    System.err.println("Transaction 2: Error updating id 3: " + e.getMessage());
                }

                // 事务 1: 提交事务，释放锁
                conn1.commit();
                System.out.println("Transaction 1: Committed and released Next-Key Lock");

            } catch (SQLException e) {
                System.err.println("Transaction 1: Error acquiring Next-Key Lock: " + e.getMessage());
                conn1.rollback();
            }

        } catch (SQLException e) {
            System.err.println("Connection error: " + e.getMessage());
        }
    }
}

MySQL 表结构 (products):

CREATE TABLE products (
  id INT PRIMARY KEY,
  name VARCHAR(255),
  price DECIMAL(10, 2)
);

INSERT INTO products (id, name, price) VALUES (1, 'Product A', 10.00);
INSERT INTO products (id, name, price) VALUES (3, 'Product C', 12.00);
INSERT INTO products (id, name, price) VALUES (4, 'Product D', 13.00);

代码解释:

范围查询: 事务 1 使用 SELECT * FROM products WHERE id >= 2 AND id <= 3 FOR UPDATE 语句进行范围查询。由于 id 是主键索引，InnoDB 会对以下范围加 Next-Key Lock：
- (1, 2]：锁定 id=2 记录之前的间隙和 id=2 记录本身。由于 id=1 存在，实际上锁定的范围是从无穷小到2，因为 id=1 本身也会被锁定。
- (2, 3]：锁定 id=3 记录之前的间隙和 id=3 记录本身。
尝试插入: 事务 2 尝试在间隙 (1, 2) 中插入一条新的记录 id = 2。由于事务 1 已经持有该间隙的 Next-Key Lock，事务 2 的插入操作会被阻塞。
尝试修改: 事务 2 尝试修改 id = 3 的记录。由于事务 1 已经持有该记录的 Next-Key Lock，事务 2 的修改操作会被阻塞。
提交事务 1: 事务 1 提交事务，释放 Next-Key Lock。
事务 2 解锁: 事务 1 释放锁后，事务 2 就可以插入或修改数据并继续执行。

InnoDB 锁的底层实现细节

InnoDB 的锁信息存储在内存中的锁系统中，主要涉及以下几个数据结构：

Lock Table (锁表): 一个全局的数据结构，存储所有当前被持有的锁信息。每个锁项包含锁的类型（Record Lock, Gap Lock, Next-Key Lock）、锁的模式（S-lock, X-lock）、锁定的对象（表、索引、记录）、持有锁的事务 ID 等信息。
Transaction Table (事务表): 一个全局的数据结构，存储所有活跃事务的信息。每个事务项包含事务 ID、事务状态、持有的锁列表等信息。
Index Tree (索引树): InnoDB 使用 B+ 树来存储索引。Record Lock 和 Next-Key Lock 直接在索引树的叶子节点上进行标记，表示该记录或间隙被锁定。

锁的获取流程:

事务发起请求: 事务在执行 SQL 语句时，如果需要对数据进行锁定，会向锁系统发起锁请求。
锁系统检查冲突: 锁系统会检查 Lock Table 中是否存在与当前请求冲突的锁。如果存在冲突，则将当前事务放入等待队列，直到持有锁的事务释放锁。
授予锁: 如果没有冲突，锁系统会在 Lock Table 中创建新的锁项，并将锁授予当前事务。
更新事务表: 锁系统会将授予的锁信息添加到当前事务的 Transaction Table 中。
标记索引树: 如果是 Record Lock 或 Next-Key Lock，锁系统会在索引树的叶子节点上进行标记，表示该记录或间隙被锁定。

锁的释放流程:

事务结束: 当事务提交或回滚时，会向锁系统发起锁释放请求。
锁系统释放锁: 锁系统会从 Lock Table 中删除该事务持有的所有锁项。
更新事务表: 锁系统会将释放的锁信息从当前事务的 Transaction Table 中移除。
移除索引树标记: 如果是 Record Lock 或 Next-Key Lock，锁系统会从索引树的叶子节点上移除相应的标记。
唤醒等待事务: 锁系统会检查等待队列中是否存在等待该锁的事务，如果有，则唤醒这些事务，让它们重新尝试获取锁。

死锁检测与解决

死锁是指两个或多个事务相互等待对方释放锁，导致所有事务都无法继续执行的情况。InnoDB 具有死锁检测机制，可以自动检测到死锁并选择一个事务进行回滚，从而解除死锁。

死锁检测算法： InnoDB 使用 Wait-For Graph 算法进行死锁检测。该算法构建一个事务等待图，其中节点表示事务，边表示事务之间的等待关系。如果图中存在环路，则表示存在死锁。
死锁解决策略： 当检测到死锁时，InnoDB 会选择一个事务进行回滚。选择的策略通常是回滚代价最小的事务，例如执行时间最短、持有锁数量最少的事务。

总结：理解锁机制，提升并发性能

理解 InnoDB 的 Record Lock、Gap Lock 和 Next-Key Lock 的底层实现对于编写高性能、高并发的数据库应用至关重要。合理地使用索引、优化 SQL 语句、选择合适的事务隔离级别，可以减少锁冲突，提高并发性能。避免长事务，尽量减小事务的范围和持有锁的时间，也是优化并发性能的重要手段。

InnoDB 存储引擎内部之锁机制深度解析：Record Lock、Gap Lock、Next-Key Lock

发表回复 取消回复

发表回复取消回复