mysql insert 时出现Deadlock死锁场景分析

原创

疯狂的KK

发布于 2024-08-19 15:27:05

2070

发布于 2024-08-19 15:27:05

文章被收录于专栏：Java项目实战

当两个事务同时对同一个表进行插入操作时，可能会遇到令人头疼的"Deadlock found when trying to get lock"错误。

死锁的根源：理解事务与锁

在Java开发中，事务通常遵循ACID原则：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）。为了保证这些原则，数据库管理系统（DBMS）会使用锁机制来控制并发访问。当两个事务尝试同时修改同一数据时，如果没有合适的锁策略，就可能发生死锁。

死锁的定义

死锁是指两个或多个事务在执行过程中，因争夺资源而造成的一种僵局。在这种情况下，每个事务都持有一些资源，并且等待其他事务释放它们所需的资源，但这些资源又被其他事务所持有，导致所有事务都无法继续执行。

死锁的产生条件

互斥条件：资源不能被多个事务共享，只能由一个事务独占。
持有和等待条件：事务至少持有一个资源，并等待获取其他事务持有的资源。
不可剥夺条件：资源请求者不能强行从资源持有者那里获取资源，只能等待释放。
循环等待条件：存在一个事务间的资源请求循环。

MySQL中常见的锁分类：

全局锁（Global Locks）
- 全局读锁（Global Read Lock）
- 全局写锁（Global Write Lock）
表级锁（Table-level Locks）
- 表共享读锁（Table Read Lock）
- 表独占写锁（Table Write Lock）
行级锁（Row-level Locks）
- 共享锁（Shared Locks），其他事务可以读取该行但不能修改。
- 排他锁（Exclusive Locks），阻止其他事务读取或修改该行。
间隙锁（Gap Locks）
- 用于锁定某个范围内但不包括记录本身的间隙。
记录锁（Record Locks）
- 直接锁定某条记录。
临键锁（Next-Key Locks）
- 结合了记录锁和间隙锁，用于行级并发控制。
意向锁（Intention Locks）
- 用于在锁定层次结构中表明锁定意图，分为意向共享锁和意向排他锁。
自增锁（Auto-increment Locks）
- 用于控制自增字段的值的生成，防止并发插入时产生重复的自增值。
元数据锁（Metadata Locks）
- 用于控制对数据库结构的修改，如添加或删除表、索引等。
快照读（Snapshot Read）
- 一种特殊的读操作，不会产生锁，通过MVCC（多版本并发控制）实现。
乐观锁（Optimistic Locks）
- 通常通过版本号或时间戳来实现，不是数据库层面的锁，而是应用层面的逻辑。
悲观锁（Pessimistic Locks）
- 通过数据库锁机制实现，如SELECT ... FOR UPDATE。

每种锁类型都有其特定的用途和适用场景，开发者需要根据实际的业务需求和并发情况来选择合适的锁策略。

死锁场景再现：Java事务中的示例

让我们通过一个简单的Java代码示例来展示死锁是如何产生的：

public class TransactionExample {
    public static void main(String[] args) {
        Connection conn1 = ...; // 获取数据库连接1
        Connection conn2 = ...; // 获取数据库连接2

        new Thread(() -> {
            try {
                conn1.setAutoCommit(false);
                // 执行一些数据库操作
                // ...
                // 插入操作1
                conn1.createStatement().execute("INSERT INTO table_name (column1) VALUES (value1)");
                // 插入操作2
                conn1.createStatement().execute("INSERT INTO another_table (column1) VALUES (value2)");
                conn1.commit();
            } catch (SQLException e) {
                e.printStackTrace();
                try {
                    conn1.rollback();
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
        }).start();

        new Thread(() -> {
            try {
                conn2.setAutoCommit(false);
                // 执行一些数据库操作
                // ...
                // 插入操作2
                conn2.createStatement().execute("INSERT INTO another_table (column1) VALUES (value2)");
                // 插入操作1
                conn2.createStatement().execute("INSERT INTO table_name (column1) VALUES (value1)");
                conn2.commit();
            } catch (SQLException e) {
                e.printStackTrace();
                try {
                    conn2.rollback();
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
        }).start();
    }
}

在这个例子中，两个线程分别代表两个事务，它们尝试以不同的顺序对两个表进行插入操作。如果两个事务几乎同时开始，并且都试图获取对方的锁，就可能发生死锁。