MySQL存储引擎内部之：`InnoDB`的`事务`：`ACID`特性在`InnoDB`中的底层实现。

admin
Sun, 31 Aug 2025 08:30:29 +0000
Mysql, acid, innodb, mysql

MySQL InnoDB 事务 ACID 特性底层实现详解 大家好，今天我们来深入探讨 MySQL InnoDB 存储引擎中事务的 ACID 特性，以及它们在底层是如何实现的。ACID 是数据库事务的基石，理解其实现机制对于编写健壮、可靠的数据库应用至关重要。 1. ACID 特性概览 ACID 分别代表： 原子性 (Atomicity): 事务是不可分割的工作单元，要么全部成功，要么全部失败。 一致性 (Consistency): 事务必须保证数据库从一个一致性状态转变到另一个一致性状态。 隔离性 (Isolation): 并发执行的事务之间应该相互隔离，互不干扰。 持久性 (Durability): 一旦事务提交，其结果应该永久保存，即使系统发生故障也不会丢失。 2. 原子性 (Atomicity) 的实现：Undo Log InnoDB 使用 Undo Log 来实现原子性。Undo Log 记录了事务修改数据之前的原始版本。如果在事务执行过程中发生错误或需要回滚，InnoDB 可以利用 Undo Log 将数据恢复到事务开始之前的状态。 Undo Log 的工作原理： 当事务开 …

继续阅读“MySQL存储引擎内部之：`InnoDB`的`事务`：`ACID`特性在`InnoDB`中的底层实现。”

The post MySQL存储引擎内部之：`InnoDB`的`事务`：`ACID`特性在`InnoDB`中的底层实现。 first appeared on 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座.

MySQL InnoDB 事务 ACID 特性底层实现详解

大家好，今天我们来深入探讨 MySQL InnoDB 存储引擎中事务的 ACID 特性，以及它们在底层是如何实现的。ACID 是数据库事务的基石，理解其实现机制对于编写健壮、可靠的数据库应用至关重要。

1. ACID 特性概览

ACID 分别代表：

原子性 (Atomicity): 事务是不可分割的工作单元，要么全部成功，要么全部失败。

一致性 (Consistency): 事务必须保证数据库从一个一致性状态转变到另一个一致性状态。

隔离性 (Isolation): 并发执行的事务之间应该相互隔离，互不干扰。

持久性 (Durability): 一旦事务提交，其结果应该永久保存，即使系统发生故障也不会丢失。

2. 原子性 (Atomicity) 的实现：Undo Log

InnoDB 使用 Undo Log 来实现原子性。Undo Log 记录了事务修改数据之前的原始版本。如果在事务执行过程中发生错误或需要回滚，InnoDB 可以利用 Undo Log 将数据恢复到事务开始之前的状态。

Undo Log 的工作原理：

1. 当事务开始修改数据时，InnoDB 会将修改之前的数据拷贝到 Undo Log 中。Undo Log 通常是物理日志，记录了每个修改操作的详细信息。

2. 如果事务成功提交，Undo Log 可以被丢弃或保留一段时间用于其他目的（例如，MVCC）。

3. 如果事务需要回滚，InnoDB 会读取 Undo Log 中的记录，按照相反的顺序执行操作，将数据恢复到原始状态。

Undo Log 的存储：

Undo Log 存储在特殊的 Undo 表空间中。InnoDB 支持多种 Undo 表空间配置，包括独立 Undo 表空间和系统 Undo 表空间。

代码示例 (模拟 Undo Log 机制):

class UndoLogEntry:
    def __init__(self, table_name, row_id, old_value):
        self.table_name = table_name
        self.row_id = row_id
        self.old_value = old_value

class Transaction:
    def __init__(self, db):
        self.db = db
        self.undo_log = []
        self.is_active = True

    def update(self, table_name, row_id, new_value):
        if not self.is_active:
            raise Exception("Transaction is not active")

        old_value = self.db.get(table_name, row_id)
        if old_value is None:
            raise Exception("Row not found")

        self.undo_log.append(UndoLogEntry(table_name, row_id, old_value))
        self.db.set(table_name, row_id, new_value)
        print(f"Updated {table_name}.{row_id} from {old_value} to {new_value}")

    def commit(self):
        if not self.is_active:
            raise Exception("Transaction is not active")
        print("Transaction committed")
        self.is_active = False

    def rollback(self):
        if not self.is_active:
            raise Exception("Transaction is not active")

        print("Rolling back transaction")
        for entry in reversed(self.undo_log):
            self.db.set(entry.table_name, entry.row_id, entry.old_value)
            print(f"Restored {entry.table_name}.{entry.row_id} to {entry.old_value}")
        self.is_active = False

class InMemoryDB:
    def __init__(self):
        self.data = {}

    def get(self, table_name, row_id):
        if table_name in self.data and row_id in self.data[table_name]:
            return self.data[table_name][row_id]
        return None

    def set(self, table_name, row_id, value):
        if table_name not in self.data:
            self.data[table_name] = {}
        self.data[table_name][row_id] = value

# Example Usage
db = InMemoryDB()
db.set("users", 1, "Alice")

tx = Transaction(db)
try:
    tx.update("users", 1, "Alice NewName")
    tx.commit()
except Exception as e:
    print(f"Error: {e}")
    tx.rollback()

print(db.data) # Output: {'users': {1: 'Alice NewName'}}

db = InMemoryDB()
db.set("users", 1, "Alice")

tx = Transaction(db)
try:
    tx.update("users", 1, "Alice NewName")
    raise Exception("Simulating an error") # Simulating an error
    tx.commit()
except Exception as e:
    print(f"Error: {e}")
    tx.rollback()

print(db.data) # Output: {'users': {1: 'Alice'}}

这个 Python 代码只是一个简化的模拟，展示了 Undo Log 的基本概念。实际的 InnoDB Undo Log 实现要复杂得多，涉及物理日志格式、并发控制、性能优化等方面。

3. 一致性 (Consistency) 的实现：约束，触发器和应用逻辑

InnoDB 本身无法直接保证一致性，一致性更多的是依赖于数据库的约束、触发器以及应用逻辑来保证的。InnoDB 提供了多种机制来帮助维护一致性：

约束 (Constraints): 包括主键约束、唯一约束、外键约束、非空约束等。这些约束可以防止非法数据进入数据库。

触发器 (Triggers): 可以在特定的数据库事件（例如，插入、更新、删除）发生时自动执行的代码。触发器可以用来检查数据的一致性，或者执行一些额外的操作来维护一致性。

数据类型: 确保数据的正确存储和使用。

应用逻辑: 最终，一致性需要由应用程序来保证，应用程序需要正确处理数据，并遵循业务规则。

代码示例 (约束):

-- 创建一个表，并添加主键约束和非空约束
CREATE TABLE users (
    id INT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    age INT
);

-- 尝试插入违反约束的数据
INSERT INTO users (id, name, age) VALUES (1, NULL, 20);  -- 违反非空约束
-- ERROR 1048 (23000): Column 'name' cannot be null

INSERT INTO users (id, name, age) VALUES (1, 'Bob', 20);  -- 违反主键约束（重复的 id）
-- ERROR 1062 (23000): Duplicate entry '1' for key 'users.PRIMARY'

代码示例 (触发器):

-- 创建一个表
CREATE TABLE orders (
    id INT PRIMARY KEY,
    user_id INT,
    amount DECIMAL(10, 2)
);

-- 创建一个触发器，在插入订单时检查金额是否为正数
DELIMITER //
CREATE TRIGGER check_amount_before_insert
BEFORE INSERT ON orders
FOR EACH ROW
BEGIN
    IF NEW.amount <= 0 THEN
        SIGNAL SQLSTATE '45000'
        SET MESSAGE_TEXT = 'Amount must be positive';
    END IF;
END;//
DELIMITER ;

-- 尝试插入金额为负数的订单
INSERT INTO orders (id, user_id, amount) VALUES (1, 1, -10.00);
-- ERROR 1644 (45000): Amount must be positive

4. 隔离性 (Isolation) 的实现：锁和 MVCC

InnoDB 使用锁和多版本并发控制 (MVCC) 来实现隔离性。

4.1 锁 (Locks):

InnoDB 支持多种类型的锁，包括：

共享锁 (Shared Lock, S Lock): 允许事务读取数据。多个事务可以同时持有同一个资源的共享锁。

排他锁 (Exclusive Lock, X Lock): 允许事务修改数据。只有一个事务可以持有同一个资源的排他锁。

意向锁 (Intention Lock, I Lock): 表示事务打算在某个资源上获取共享锁或排他锁。意向锁可以提高锁的并发性能。InnoDB有IS锁和IX锁。

记录锁 (Record Lock): 锁定一条记录。

间隙锁 (Gap Lock): 锁定一个范围，防止其他事务在这个范围内插入新的记录。

临键锁 (Next-Key Lock): 记录锁和间隙锁的组合，锁定一条记录以及该记录之前的间隙。

锁的类型和兼容性:

锁类型 | 共享锁 (S) | 排他锁 (X) | 意向共享锁 (IS) | 意向排他锁 (IX)
共享锁 (S) | 兼容 | 不兼容 | 兼容 | 不兼容
排他锁 (X) | 不兼容 | 不兼容 | 不兼容 | 不兼容
意向共享锁 (IS) | 兼容 | 不兼容 | 兼容 | 兼容
意向排他锁 (IX) | 不兼容 | 不兼容 | 兼容 | 兼容

代码示例 (锁):

-- 事务 1
START TRANSACTION;
SELECT * FROM users WHERE id = 1 FOR UPDATE;  -- 获取排他锁
-- 在这个事务中，其他事务无法修改 id = 1 的记录
UPDATE users SET name = 'Charlie' WHERE id = 1;
COMMIT;

-- 事务 2
START TRANSACTION;
SELECT * FROM users WHERE id = 1 LOCK IN SHARE MODE;  -- 获取共享锁
-- 在这个事务中，其他事务可以读取 id = 1 的记录，但无法修改
SELECT * FROM users WHERE id = 1;
COMMIT;

4.2 多版本并发控制 (MVCC):

MVCC 是一种并发控制技术，允许事务读取数据时不需要获取锁。InnoDB 通过在每一行数据中存储多个版本来实现 MVCC。每个版本都有一个事务 ID，表示创建该版本的事务。

MVCC 的工作原理：

1. 当事务开始时，InnoDB 会为其分配一个唯一的事务 ID。

2. 当事务读取数据时，InnoDB 会选择一个合适的版本。选择的规则通常是：

该版本是由已提交的事务创建的。

该版本的事务 ID 小于或等于当前事务的事务 ID。

该版本的删除事务 ID 大于当前事务的事务 ID，或者删除事务 ID 为空（表示该版本未被删除）。

3. 当事务修改数据时，InnoDB 不会直接覆盖原始数据，而是创建一个新的版本。新版本的事务 ID 是当前事务的事务 ID，并指向原始版本。

4. 当事务提交时，InnoDB 会将新版本标记为已提交。

5. 当事务回滚时，InnoDB 会丢弃新版本，并恢复到原始版本。

MVCC 的优点：

提高并发性能：读取数据不需要获取锁，减少了锁的竞争。

提供一致性读：事务读取的数据是在事务开始时的一个快照，保证了数据的一致性。

MVCC 的缺点：

需要额外的存储空间来存储多个版本的数据。

需要定期清理旧版本的数据，以避免存储空间耗尽。

MVCC 示意图：

假设我们有一行数据，初始值为 "Alice"，事务 ID 为 10。

事务 ID | 操作 | 数据值
10 | 创建 | Alice

现在，事务 20 修改了这行数据，将其更新为 "Bob"。

事务 ID | 操作 | 数据值 | 指向旧版本
10 | 创建 | Alice |
20 | 更新 | Bob | 10

如果事务 30 读取这行数据，它会根据 MVCC 的规则选择版本。如果事务 30 的隔离级别是 READ COMMITTED，它会选择事务 20 创建的版本 "Bob"。如果事务 30 的隔离级别是 REPEATABLE READ，它会选择事务 10 创建的版本 "Alice"。

InnoDB 的隔离级别：

InnoDB 支持四种隔离级别：

READ UNCOMMITTED: 允许读取未提交的数据。最低的隔离级别，可能导致脏读、不可重复读和幻读。

READ COMMITTED: 只允许读取已提交的数据。可以避免脏读，但可能导致不可重复读和幻读。

REPEATABLE READ: 保证在同一个事务中多次读取同一数据的结果是一致的。可以避免脏读和不可重复读，但可能导致幻读。InnoDB默认的隔离级别。

SERIALIZABLE: 最高的隔离级别，通过强制事务串行执行来避免所有并发问题。可以避免脏读、不可重复读和幻读，但并发性能最低。

代码示例 (模拟 MVCC 机制):

class DataVersion:
    def __init__(self, value, tx_id, delete_tx_id=None):
        self.value = value
        self.tx_id = tx_id
        self.delete_tx_id = delete_tx_id

class MVCCDB:
    def __init__(self):
        self.data = {}  # {table_name: {row_id: [DataVersion]}}
        self.current_tx_id = 1

    def begin_transaction(self):
        tx_id = self.current_tx_id
        self.current_tx_id += 1
        return tx_id

    def get(self, table_name, row_id, tx_id):
        if table_name not in self.data or row_id not in self.data[table_name]:
            return None

        versions = self.data[table_name][row_id]
        # Find the latest version visible to this transaction
        visible_version = None
        for version in reversed(versions): # Iterate from newest to oldest
            if version.tx_id <= tx_id and (version.delete_tx_id is None or version.delete_tx_id > tx_id):
                visible_version = version
                break

        if visible_version:
            return visible_version.value
        else:
            return None

    def set(self, table_name, row_id, value, tx_id):
        if table_name not in self.data:
            self.data[table_name] = {}

        if row_id not in self.data[table_name]:
            self.data[table_name][row_id] = []

        self.data[table_name][row_id].append(DataVersion(value, tx_id))

    def delete(self, table_name, row_id, tx_id):
        if table_name not in self.data or row_id not in self.data[table_name]:
            return

        versions = self.data[table_name][row_id]
        # Mark the latest version as deleted by this transaction
        if versions:
            versions[-1].delete_tx_id = tx_id

# Example Usage
db = MVCCDB()

# Transaction 1
tx1_id = db.begin_transaction()
db.set("users", 1, "Alice", tx1_id)
print(f"Tx {tx1_id}: Set users.1 to Alice")

# Transaction 2
tx2_id = db.begin_transaction()
print(f"Tx {tx2_id}: users.1 = {db.get('users', 1, tx2_id)}") # None (uncommitted data)
db.set("users", 1, "Bob", tx2_id)
print(f"Tx {tx2_id}: Set users.1 to Bob")

# Transaction 1
print(f"Tx {tx1_id}: users.1 = {db.get('users', 1, tx1_id)}") # Alice
db.delete("users", 1, tx1_id)
print(f"Tx {tx1_id}: Deleted users.1")

# Transaction 2
print(f"Tx {tx2_id}: users.1 = {db.get('users', 1, tx2_id)}") # Bob

# Transaction 3
tx3_id = db.begin_transaction()
print(f"Tx {tx3_id}: users.1 = {db.get('users', 1, tx3_id)}") # None because tx1 deleted it, and tx2 is uncommitted

这个 Python 代码只是一个简化的模拟，展示了 MVCC 的基本概念。实际的 InnoDB MVCC 实现要复杂得多，涉及事务 ID 管理、版本链维护、垃圾回收等方面。

5. 持久性 (Durability) 的实现：Redo Log

InnoDB 使用 Redo Log 来实现持久性。Redo Log 记录了事务对数据页的修改操作。即使系统发生崩溃，InnoDB 也可以利用 Redo Log 将数据恢复到事务提交之后的状态。

Redo Log 的工作原理：

1. 当事务开始修改数据时, InnoDB 会将修改操作记录到 Redo Log 中。Redo Log 通常是物理日志，记录了每个修改操作的详细信息，例如，修改了哪个数据页的哪个位置，修改前的值是什么，修改后的值是什么。

2. Redo Log 会先写入到 Redo Log Buffer 中。Redo Log Buffer 是一个内存区域，用于缓存 Redo Log 记录。

3. InnoDB 会定期将 Redo Log Buffer 中的记录刷新到 Redo Log 文件中。刷新 Redo Log 的时机包括：

事务提交时。

Redo Log Buffer 达到一定容量时。

后台线程定期刷新。

4. 当系统发生崩溃时，InnoDB 会在重启后自动执行恢复操作。恢复操作包括：

读取 Redo Log 文件中的记录。

将 Redo Log 记录应用到数据页上，将数据恢复到事务提交之后的状态。

如果事务在崩溃时还没有提交，则回滚该事务。

Redo Log 的存储：

Redo Log 存储在 Redo Log 文件中。InnoDB 支持多个 Redo Log 文件，并采用循环写入的方式。当一个 Redo Log 文件写满时，InnoDB 会自动切换到下一个 Redo Log 文件。

代码示例 (模拟 Redo Log 机制):

import os

class RedoLogEntry:
    def __init__(self, table_name, row_id, new_value):
        self.table_name = table_name
        self.row_id = row_id
        self.new_value = new_value

class RedoLog:
    def __init__(self, log_file):
        self.log_file = log_file
        # Create log file if it doesn't exist
        if not os.path.exists(self.log_file):
            open(self.log_file, 'w').close()

    def append(self, entry):
        with open(self.log_file, 'a') as f:
            f.write(f"{entry.table_name},{entry.row_id},{entry.new_value}n")

    def replay(self, db):
        with open(self.log_file, 'r') as f:
            for line in f:
                table_name, row_id, new_value = line.strip().split(',')
                db.set(table_name, int(row_id), new_value)
                print(f"Replayed: Set {table_name}.{row_id} to {new_value}")

class Transaction:
    def __init__(self, db, redo_log):
        self.db = db
        self.redo_log = redo_log
        self.is_active = True

    def update(self, table_name, row_id, new_value):
        if not self.is_active:
            raise Exception("Transaction is not active")

        self.db.set(table_name, row_id, new_value)
        self.redo_log.append(RedoLogEntry(table_name, row_id, new_value))
        print(f"Updated {table_name}.{row_id} to {new_value}")

    def commit(self):
        if not self.is_active:
            raise Exception("Transaction is not active")
        print("Transaction committed")
        self.is_active = False

class InMemoryDB:
    def __init__(self):
        self.data = {}

    def get(self, table_name, row_id):
        if table_name in self.data and row_id in self.data[table_name]:
            return self.data[table_name][row_id]
        return None

    def set(self, table_name, row_id, value):
        if table_name not in self.data:
            self.data[table_name] = {}
        self.data[table_name][row_id] = value

# Example Usage

# Simulate a crash by clearing the database and replaying the redo log
def simulate_crash(db, redo_log):
    db.data = {}
    print("Simulating a crash...")
    print("Replaying redo log...")
    redo_log.replay(db)

db = InMemoryDB()
redo_log = RedoLog("redo.log")

tx = Transaction(db, redo_log)
tx.update("users", 1, "Alice")
tx.commit()

print(db.data) # Output: {'users': {1: 'Alice'}}

simulate_crash(db, redo_log)

print(db.data) # Output: {'users': {1: 'Alice'}}

这个 Python 代码只是一个简化的模拟，展示了 Redo Log 的基本概念。实际的 InnoDB Redo Log 实现要复杂得多，涉及物理日志格式、Checkpoint 机制、性能优化等方面。

6. Checkpoint 机制

为了减少恢复时间，InnoDB 使用 Checkpoint 机制。Checkpoint 是一个时间点，表示所有脏页（已修改但尚未刷新到磁盘的数据页）都已经刷新到磁盘。InnoDB 会定期执行 Checkpoint 操作，并将 Checkpoint 信息记录到 Redo Log 文件中。

在恢复过程中，InnoDB 只需要从最近的 Checkpoint 开始重放 Redo Log 记录，而不需要重放整个 Redo Log 文件。这大大缩短了恢复时间。

7. 总结：InnoDB 如何保障 ACID

InnoDB 通过 Undo Log 实现原子性，通过约束和触发器保证一致性，通过锁和 MVCC 实现隔离性，通过 Redo Log 实现持久性。这些机制共同保证了 InnoDB 事务的 ACID 特性，确保了数据的完整性和可靠性。

8. 事务特性依赖于底层机制的协作

要真正理解 InnoDB 事务的 ACID 特性，需要深入了解其底层的实现机制，包括 Undo Log、锁、MVCC、Redo Log 和 Checkpoint。这些机制相互协作，共同保证了事务的正确执行。理解这些机制对于编写高性能、高可靠性的数据库应用至关重要。

9. 选择合适的隔离级别是关键

在实际应用中，需要根据业务需求选择合适的隔离级别。较高的隔离级别可以提供更强的数据一致性保证，但会降低并发性能。较低的隔离级别可以提高并发性能，但可能导致数据不一致的问题。

10. 持续学习和实践

数据库技术是一个不断发展的领域。为了更好地理解和应用 InnoDB 事务的 ACID 特性，需要持续学习和实践，关注最新的技术发展，并结合实际应用场景进行深入研究。