恋恋风辰的官方博客

私聊功能代码中的死锁分析
Posted on 2026-01-03 18:33:51 by 恋恋风辰 | In C++ | 原文链接

📌 问题概述

这段代码在高并发场景下会发生死锁，原因是不合理的 FOR UPDATE 查询 结合后续的 INSERT 操作，导致间隙锁、插入意向锁之间的冲突。

表结构

private_chat表

image-20251126232246544

chat_thread表

image-20251126232625472

聊天界面

image.png

📌死锁源码

  1. bool MysqlDao::CreatePrivateChat(int user1_id, int user2_id, int& thread_id)
  2. {
  3.     auto con = pool_->getConnection();
  4.     if (!con) {
  5.         return false;
  6.     }
  7.     Defer defer([this, &con]() {
  8.         pool_->returnConnection(std::move(con));
  9.         });
  10.     auto& conn = con->_con;
  11.     try {
  12.         // 开启事务
  13.         conn->setAutoCommit(false);
  14.         // 1. 查询是否已存在私聊并加行级锁
  15.         int uid1 = std::min(user1_id, user2_id);
  16.         int uid2 = std::max(user1_id, user2_id);
  17.         std::string check_sql =
  18.             "SELECT thread_id FROM private_chat "
  19.             "WHERE (user1_id = ? AND user2_id = ?) "
  20.             "FOR UPDATE;";
  22.         std::unique_ptr<sql::PreparedStatement> pstmt(conn->prepareStatement(check_sql));
  23.         pstmt->setInt64(1, uid1);
  24.         pstmt->setInt64(2, uid2);
  25.         std::unique_ptr<sql::ResultSet> res(pstmt->executeQuery());
  27.         if (res->next()) {
  28.             // 如果已存在，返回该 thread_id
  29.             thread_id = res->getInt("thread_id");
  30.             conn->commit();  // 提交事务
  31.             return true;
  32.         }
  34.         // 2. 如果未找到，创建新的 chat_thread 和 private_chat 记录
  35.         // 在 chat_thread 表插入新记录
  36.         std::string insert_chat_thread_sql =
  37.             "INSERT INTO chat_thread (type, created_at) VALUES ('private', NOW());";
  39.         std::unique_ptr<sql::PreparedStatement> pstmt_insert_thread(conn->prepareStatement(insert_chat_thread_sql));
  40.         pstmt_insert_thread->executeUpdate();
  42.         // 获取新插入的 thread_id
  43.         std::string get_last_insert_id_sql = "SELECT LAST_INSERT_ID();";
  44.         std::unique_ptr<sql::PreparedStatement> pstmt_last_insert_id(conn->prepareStatement(get_last_insert_id_sql));
  45.         std::unique_ptr<sql::ResultSet> res_last_id(pstmt_last_insert_id->executeQuery());
  46.         res_last_id->next();
  47.         thread_id = res_last_id->getInt(1);
  49.         // 3. 在 private_chat 表插入新记录
  50.         std::string insert_private_chat_sql =
  51.             "INSERT INTO private_chat (thread_id, user1_id, user2_id, created_at) "
  52.             "VALUES (?, ?, ?, NOW());";
  55.         std::unique_ptr<sql::PreparedStatement> pstmt_insert_private(conn->prepareStatement(insert_private_chat_sql));
  56.         pstmt_insert_private->setInt64(1, thread_id);
  57.         pstmt_insert_private->setInt64(2, uid1);
  58.         pstmt_insert_private->setInt64(3, uid2);
  59.         pstmt_insert_private->executeUpdate();
  61.         // 提交事务
  62.         conn->commit();
  63.         return true;
  64.     }
  65.     catch (sql::SQLException& e) {
  66.         std::cerr << "SQLException: " << e.what() << std::endl;
  67.         conn->rollback();
  68.         return false;
  69.     }
  70.     return false;
  71. }

image-20251204130749212

InnoDB 的四种主要锁类型

按粒度分类

MySQL InnoDB存储引擎中这四种重要的锁类型：

记录锁（Record Lock）

记录锁是最基本的行锁类型，它锁定的是索引记录本身。当你使用唯一索引或主键进行等值查询并且找到记录时，InnoDB会使用记录锁。

例如：SELECT * FROM users WHERE id = 10 FOR UPDATE，这会在id=10的索引记录上加记录锁。

临键锁（Next-Key Lock）

临键锁是记录锁和间隙锁的组合，锁定了一个范围，包括记录本身。这是InnoDB默认的行锁算法，主要用于解决幻读问题。

临键锁的范围是左开右闭区间，比如索引值为10, 20, 30的记录，临键锁可能是：

  • (-∞, 10]
  • (10, 20]
  • (20, 30]
  • (30, +∞)

当进行范围查询时，InnoDB通常会使用临键锁来锁定扫描到的索引范围，防止其他事务在这个范围内插入新记录

插入意向锁（Insert Intention Lock）

插入意向锁是一种特殊的间隙锁，在INSERT操作之前设置。它的特点是：

  1. 不会阻塞其他插入意向锁：多个事务可以同时在同一个间隙中获取插入意向锁，只要它们插入的位置不同
  2. 会被间隙锁和临键锁阻塞：如果间隙已经被其他事务的间隙锁或临键锁锁定，插入操作会等待
  3. 提高并发性：允许多个事务并发地向同一间隙插入不同的记录

例如，如果索引中有记录10和20，两个事务可以同时在(10, 20)这个间隙中插入不同的值（如12和15），因为插入意向锁之间不冲突。

这三种锁机制共同协作，在保证数据一致性的同时，尽可能提高并发性能。

间隙锁 (Gap Lock) │
• 锁定索引记录之间的间隙 │
• 不包括记录本身 │
• 例如: 记录3和记录7之间的空隙

临键锁如何工作

让我用具体的例子来解释临键锁是如何”组合”记录锁和间隙锁的。

先理解间隙锁（Gap Lock）

间隙锁锁定的是两个索引记录之间的间隙,不包括记录本身。它的作用是防止其他事务在这个间隙中插入新记录。

临键锁的组合特性

假设有一张表，索引列有值：10, 20, 30

  1. 索引值:    10        20        30
  2. 间隙:   (∞,10)  (10,20)  (20,30)  (30,∞)

临键锁 = 间隙锁 + 记录锁，具体来说：

临键锁 (10, 20] 意味着：

  • 间隙锁部分：锁定 (10, 20) 这个开区间，防止插入11-19的记录
  • 记录锁部分：锁定值为20的记录本身

实际场景举例

  1. -- 假设表中有记录: id = 10, 20, 30
  2. SELECT * FROM users WHERE id >= 20 FOR UPDATE;

这个查询会加临键锁：

  • (10, 20] - 锁住间隙(10,20)和记录20
  • (20, 30] - 锁住间隙(20,30)和记录30
  • (30, +∞) - 锁住30之后的所有间隙

为什么要这样组合？

这种组合设计巧妙地解决了幻读问题：

  1. -- 事务A
  2. SELECT * FROM users WHERE id >= 20 FOR UPDATE;
  3. -- 结果：找到id=20, 30两条记录
  5. -- 如果只有记录锁，事务B可以：
  6. INSERT INTO users VALUES (25, 'New');  -- 成功插入！
  8. -- 事务A再次查询
  9. SELECT * FROM users WHERE id >= 20 FOR UPDATE;
  10. -- 结果：找到id=20, 25, 30三条记录 ← 出现幻读！

但有了临键锁的间隙锁部分，事务B的插入会被阻塞，因为25落在了(20,30]的间隙范围内。

总结理解

临键锁 = 锁住一个范围的两个部分：

  1. 记录锁部分：锁住右边界的那条记录（比如20）
  2. 间隙锁部分：锁住左边界到右边界之间的间隙（比如10到20之间）

这样既保护了记录本身不被修改，又保护了间隙不被插入新记录，从而在可重复读隔离级别下避免幻读。

按类型分类

共享锁（Shared Lock，S锁）- 读锁，允许多个事务同时持有

排他锁（Exclusive Lock，X锁）- 写锁，独占访问

它们的组合关系

记录锁可以是共享锁，也可以是排他锁：

  1. -- 记录锁 + 共享锁
  2. SELECT * FROM users WHERE id = 10 FOR SHARE;
  3. -- 在id=10的记录上加"共享记录锁"
  5. -- 记录锁 + 排他锁
  6. SELECT * FROM users WHERE id = 10 FOR UPDATE;
  7. -- 在id=10的记录上加"排他记录锁"
  9. UPDATE users SET name = 'John' WHERE id = 10;
  10. -- 也是加"排他记录锁"

形象的比喻

把记录锁想象成一个房间，而排他锁/共享锁是门锁的类型：

  • 共享锁（S锁）：像”阅览室”，多个人可以同时进来看书（多个事务可以同时读）
  • 排他锁（X锁）：像”编辑室”，只能一个人进去修改文档（只有一个事务可以写，其他读写都被阻塞）

完整的描述方式

所以准确的说法应该是：

  • “在这条记录上加了排他的记录锁”
  • “在这条记录上加了共享的记录锁”

🔑 间隙锁的特性

  1. 特性1: 间隙锁之间相互兼容
  2. ┌──────────────────────────────────┐
  3. │  事务A: 持有 Gap(1,5)            │
  4. │  事务B: 可以获取 Gap(1,5) ✅     │
  5. │  事务C: 可以获取 Gap(1,5) ✅     │
  6. └──────────────────────────────────┘
  8. 特性2: 间隙锁阻止插入
  9. ┌──────────────────────────────────┐
  10. │  事务A: 持有 Gap(1,5)            │
  11. │  事务B: INSERT id=3 ❌           │
  12. │         (需要插入意向锁,被阻塞)  │
  13. └──────────────────────────────────┘
  15. 特性3: 仅在 RR 隔离级别下生效
  16. ┌──────────────────────────────────┐
  17. │  REPEATABLE READ: 有间隙锁 ✅    │
  18. │  READ COMMITTED:  无间隙锁 ✅    │
  19. └──────────────────────────────────┘

🔑 插入意向锁的特性

  1. 特性1: 与间隙锁互斥
  2. ┌──────────────────────────────────┐
  3. │  事务A: 持有 Gap Lock(1,5)       │
  4. │  事务B: INSERT id=3              │
  5. │         ↓                        │
  6. │         需要 Insert Intention    │
  7. │         ❌ 被A的间隙锁阻塞       │
  8. └──────────────────────────────────┘
  10. 特性2: 插入意向锁之间可以兼容(插入不同行时)
  11. ┌──────────────────────────────────┐
  12. │  事务A: INSERT id=2 (等待中)     │
  13. │  事务B: INSERT id=4 (等待中)     │
  14. │         ↓                        │
  15. │         如果没有间隙锁阻塞       │
  16. │         两者可以并发执行 ✅      │
  17. └──────────────────────────────────┘

问题代码结构

  1. bool CreatePrivateChat(int user1_id, int user2_id, int& thread_id)
  2. {
  3.     conn->setAutoCommit(false);  // 开启事务
  5.     // ⚠️ 第一步: SELECT ... FOR UPDATE
  6.     // 如果未找到记录 → 获取间隙锁
  7.     std::string check_sql =
  8.         "SELECT thread_id FROM private_chat "
  9.         "WHERE (user1_id = ? AND user2_id = ?) "
  10.         "FOR UPDATE;";  
  12.     if (res->next()) {
  13.         // 找到记录,返回
  14.         thread_id = res->getInt("thread_id");
  15.         conn->commit();
  16.         return true;
  17.     }
  19.     // ⚠️ 第二步: INSERT 新记录
  20.     // 需要获取插入意向锁 → 与间隙锁冲突
  21.     std::string insert_sql =
  22.         "INSERT INTO private_chat "
  23.         "(thread_id, user1_id, user2_id, created_at) "
  24.         "VALUES (?, ?, ?, NOW());";
  26.     conn->commit();
  27. }

表结构假设

  1. CREATE TABLE private_chat (
  2.     thread_id INT,
  3.     user1_id INT,
  4.     user2_id INT,
  5.     created_at DATETIME,
  6.     INDEX idx_users (user1_id, user2_id)  -- 复合索引
  7. );
  9. -- 当前数据
  10. ┌──────────┬──────────┬──────────┐
  11. │ user1_id │ user2_id │thread_id │
  12. ├──────────┼──────────┼──────────┤
  13. │    1     │    3     │    10    │
  14. │    2     │    4     │    20    │
  15. │    5     │    8     │    30    │
  16. └──────────┴──────────┴──────────┘
  18. -- 索引树的间隙
  19. Gap: (-∞, (1,3))
  20. Gap: ((1,3), (2,4))  ← 死锁发生的间隙
  21. Gap: ((2,4), (5,8))
  22. Gap: ((5,8), +∞)

第三部分:死锁发生的完整流程

并发场景

两个线程同时调用: CreatePrivateChat(1, 2, thread_id)

  1. ┌─────────────────────────────────────────────────────┐
  2. │  并发请求:                                          │
  3. │  • 线程1: CreatePrivateChat(1, 2, thread_id_A)      │
  4. │  • 线程2: CreatePrivateChat(1, 2, thread_id_B)      │
  5. │                                                     │
  6. │  目标: 创建 user1_id=1, user2_id=2 的私聊          │
  7. │  索引位置: 落在间隙 ((1,3), (2,4)) 之间            │
  8. └─────────────────────────────────────────────────────┘

详细时间线

  1. 时间    事务 A                              事务 B
  2. ────────────────────────────────────────────────────────────
  3. T0      BEGIN                              BEGIN
  4.         ↓                                  ↓
  6. T1      SELECT ... FOR UPDATE              
  7.         WHERE user1_id=1 AND user2_id=2    (等待中)
  8.         ↓                                  
  9.         检查索引: (1,2)                    
  10.         ↓                                  
  11.         未找到记录                         
  12.         ↓                                  
  14. T2      获取间隙锁 Gap((1,3), (2,4)) ✅    SELECT ... FOR UPDATE
  15.         (锁定查询区间)                     WHERE user1_id=1 AND user2_id=2
  16.                                           ↓
  17.                                           检查索引: (1,2)
  18.                                           ↓
  19.                                           未找到记录
  20.                                           ↓
  22. T3      准备 INSERT                        获取间隙锁 Gap((1,3), (2,4)) ✅
  23.         thread_id = 100                    ⚠️ 间隙锁兼容! 成功获取!
  24.         ↓                                  ↓
  26. T4      INSERT INTO private_chat           准备 INSERT
  27.         VALUES (100, 1, 2, NOW())          thread_id = 101
  28.         ↓                                  ↓
  29.         需要插入意向锁                     
  30.         Insert Intention Lock              
  31.         ↓                                  
  33. T5      检测到 B 持有 Gap Lock             INSERT INTO private_chat
  34.         ❌ 插入意向锁与间隙锁冲突          VALUES (101, 1, 2, NOW())
  35.         ⏳ 等待 B 释放间隙锁...            ↓
  36.                                           需要插入意向锁
  37.                                           Insert Intention Lock
  38.                                           ↓
  40. T6      (继续等待)                         检测到 A 持有 Gap Lock
  41.         持有: Gap Lock                     ❌ 插入意向锁与间隙锁冲突
  42.         等待: B 释放 Gap Lock              ⏳ 等待 A 释放间隙锁...
  43.                                           ↓
  44.                                           持有: Gap Lock
  45.                                           等待: A 释放 Gap Lock
  47. T7      💀 DEADLOCK DETECTED!
  48.         ─────────────────────────────────────────────
  49.         MySQL 检测到循环等待:
  50.         • A 持有间隙锁, 等待 B 释放间隙锁
  51.         • B 持有间隙锁, 等待 A 释放间隙锁
  52.         ─────────────────────────────────────────────
  53.         ↓
  54.         回滚事务 B (选择代价较小的事务)
  55.         ↓
  56.         事务 A 继续执行
  57.         INSERT 成功 ✅
  58.         COMMIT ✅

第四部分:死锁的核心机制

锁兼容性矩阵

  1. ┌───────────────────────────────────────────────────┐
  2. │         锁类型兼容性(RR隔离级别)                   │
  3. ├─────────────┬────────┬──────────┬───────────────┤
  4. │  持有\请求  │ 间隙锁 │ 记录锁   │ 插入意向锁    │
  5. ├─────────────┼────────┼──────────┼───────────────┤
  6. │  间隙锁     │ ✅兼容 │ ✅兼容   │ ❌ 冲突       │
  7. │  记录锁     │ ✅兼容 │ ❌ 冲突  │ ❌ 冲突       │
  8. │  插入意向锁 │ ❌冲突 │ ❌ 冲突  │ ✅兼容(不同行)│
  9. └─────────────┴────────┴──────────┴───────────────┘
  11. ⚠️ 核心规则:
  12. • 间隙锁 + 间隙锁 = ✅ 兼容(可以同时持有)
  13. • 间隙锁 + 插入意向锁 = ❌ 冲突(互相阻塞)

死锁的四个必要条件

  1. ┌──────────────────────────────────────────────┐
  2. │         本案例中的死锁条件分析                │
  3. ├──────────────────────────────────────────────┤
  4. │                                              │
  5. │  1️⃣  互斥条件 ✅                             │
  6. │      插入意向锁 与 间隙锁 互斥               │
  7. │                                              │
  8. │  2️⃣  持有并等待 ✅                           │
  9. │      A 持有间隙锁, 等待获取插入意向锁        │
  10. │      B 持有间隙锁, 等待获取插入意向锁        │
  11. │                                              │
  12. │  3️⃣  不可剥夺 ✅                             │
  13. │      间隙锁只能在事务提交/回滚时释放         │
  14. │                                              │
  15. │  4️⃣  循环等待 ✅                             │
  16. │      A 等待 B → B 等待 A                     │
  17. │                                              │
  18. └──────────────────────────────────────────────┘

可视化流程图

  1. ┌────────────────────────────────────────────────────┐
  2. │              死锁形成的循环依赖图                   │
  3. └────────────────────────────────────────────────────┘
  5.         事务 A                      事务 B
  6.           │                           │
  7.           │                           │
  8.      [持有间隙锁]                [持有间隙锁]
  9.       Gap(1,3)~(2,4)             Gap(1,3)~(2,4)
  10.           │                           │
  11.           │                           │
  12.           ▼                           ▼
  13.     需要插入意向锁                需要插入意向锁
  14.     Insert Intention              Insert Intention
  15.           │                           │
  16.           │◄─────────┐   ┌───────────►│
  17.           │          │   │            │
  18.           │       等待B释放│ 等待A释放  │
  19.           │        间隙锁 │  间隙锁    │
  20.           │          │   │            │
  21.           └──────────┘   └────────────┘
  22.                 💀 循环等待
  25. 解释:
  26. • 两个事务都在 T2-T3 成功获取了间隙锁(兼容)
  27. • 两个事务都在 T5-T6 尝试获取插入意向锁
  28. • 插入意向锁被对方的间隙锁阻塞
  29. • 形成 A→B→A 的循环依赖

第五部分:为什么会发生死锁?

根本原因分析

  1. ┌─────────────────────────────────────────────────┐
  2. │           死锁的三个关键因素                     │
  3. └─────────────────────────────────────────────────┘
  5. 因素1: FOR UPDATE 的锁定范围
  6. ─────────────────────────────
  7. 当 SELECT ... FOR UPDATE 未找到记录时:
  8.   • 不仅扫描索引范围
  9.   • 还会对扫描的间隙加间隙锁
  10.   • 目的: 防止其他事务插入满足条件的记录(防止幻读)
  12. 查询: WHERE user1_id=1 AND user2_id=2
  13. 索引: idx_users(user1_id, user2_id)
  14. 加锁: Gap Lock on ((1,3), (2,4))
  17. 因素2: 间隙锁的兼容性
  18. ─────────────────────────────
  19. 两个事务可以同时持有同一间隙的间隙锁:
  20.   • 事务A: Gap Lock ✅
  21.   • 事务B: Gap Lock ✅ (不冲突)
  23. ⚠️ 这是死锁的前提条件!
  26. 因素3: 插入意向锁的互斥性
  27. ─────────────────────────────
  28. INSERT 操作需要获取插入意向锁:
  29.   • 检查目标间隙是否有间隙锁
  30.   • 如果有 → 等待间隙锁释放
  32. 事务A: INSERT → 需要插入意向锁 → 被B的间隙锁阻塞
  33. 事务B: INSERT → 需要插入意向锁 → 被A的间隙锁阻塞
  35. 💀 循环等待形成!

死锁可以回滚还需要修复吗

🚨 问题1: 用户体验差

  1. 用户请求流程:
  2. ┌─────────────────────────────────────────┐
  3. │  用户A: 创建与用户B的私聊               │
  4. │   ↓                                     │
  5. │  发起请求...                            │
  6. │   ↓                                     │
  7. │  💀 死锁! 事务被回滚                    │
  8. │   ↓                                     │
  9. │  返回 false                             │
  10. │   ↓                                     │
  11. │  ❌ 用户看到"创建失败"                  │
  12. │   ↓                                     │
  13. │  😤 用户体验: 明明是正常操作,为什么失败?│
  14. └─────────────────────────────────────────┘

问题: 虽然没有数据错误,但用户需要重试,体验不好。

🚨 问题2: 高并发下的性能损耗

  1. 高并发场景 (100个并发请求):
  2. ┌──────────────────────────────────────────┐
  3. │  100 个并发请求创建私聊                  │
  4. │   ↓                                      │
  5. │  • 50 个事务获取间隙锁 ✅                │
  6. │  • 50 个事务也获取间隙锁 ✅              │
  7. │   ↓                                      │
  8. │  • 所有事务尝试 INSERT                   │
  9. │  • 💀 大量死锁!                          │
  10. │   ↓                                      │
  11. │  • 50% 的事务被回滚                      │
  12. │  • 这些事务需要重试                      │
  13. │   ↓                                      │
  14. │  • 数据库压力翻倍                        │
  15. │  • CPU 消耗在死锁检测上                  │
  16. │  • 大量事务日志写入                      │
  17. └──────────────────────────────────────────┘
  19. 性能损失:
  20. • 死锁检测: 消耗 CPU
  21. • 回滚操作: 消耗 IO
  22. • 客户端重试: 消耗网络和数据库连接

第六部分:解决方案

✅先INSERT后SELECT(乐观策略)

原理: 先尝试插入,如果失败说明已存在,再查询

  1. // 在 private_chat 表上添加唯一索引
  2. // CREATE UNIQUE INDEX uk_user_pair ON private_chat(user1_id, user2_id);
  3. bool CreatePrivateChat(int user1_id, int user2_id, int& thread_id)
  4. {
  5.     auto con = pool_->getConnection();
  6.     Defer defer([this, &con]() { pool_->returnConnection(std::move(con)); });
  7.     auto& conn = con->_con;
  9.     int uid1 = std::min(user1_id, user2_id);
  10.     int uid2 = std::max(user1_id, user2_id);
  12.     try {
  13.         conn->setAutoCommit(false);
  15.         // 先创建 chat_thread
  16.         std::string insert_thread_sql =
  17.             "INSERT INTO chat_thread (type, created_at) VALUES ('private', NOW());";
  18.         std::unique_ptr<sql::PreparedStatement> pstmt_thread(
  19.             conn->prepareStatement(insert_thread_sql));
  20.         pstmt_thread->executeUpdate();
  22.         // 获取 thread_id
  23.         std::unique_ptr<sql::PreparedStatement> pstmt_id(
  24.             conn->prepareStatement("SELECT LAST_INSERT_ID();"));
  25.         std::unique_ptr<sql::ResultSet> res_id(pstmt_id->executeQuery());
  26.         res_id->next();
  27.         thread_id = res_id->getInt(1);
  29.         // ✅ 直接尝试插入
  30.         std::string insert_sql =
  31.             "INSERT INTO private_chat (thread_id, user1_id, user2_id, created_at) "
  32.             "VALUES (?, ?, ?, NOW());";
  34.         std::unique_ptr<sql::PreparedStatement> pstmt_insert(
  35.             conn->prepareStatement(insert_sql));
  36.         pstmt_insert->setInt64(1, thread_id);
  37.         pstmt_insert->setInt64(2, uid1);
  38.         pstmt_insert->setInt64(3, uid2);
  39.         pstmt_insert->executeUpdate();
  41.         conn->commit();
  42.         return true;
  43.     }
  44.     catch (sql::SQLException& e) {
  45.         conn->rollback();
  47.         // 如果是唯一键冲突 (错误码 1062)
  48.         if (e.getErrorCode() == 1062) {
  49.             // ✅ 查询已存在的记录
  50.             try {
  51.                 std::string query_sql =
  52.                     "SELECT thread_id FROM private_chat "
  53.                     "WHERE user1_id = ? AND user2_id = ?;";
  55.                 std::unique_ptr<sql::PreparedStatement> pstmt_query(
  56.                     conn->prepareStatement(query_sql));
  57.                 pstmt_query->setInt64(1, uid1);
  58.                 pstmt_query->setInt64(2, uid2);
  59.                 std::unique_ptr<sql::ResultSet> res(pstmt_query->executeQuery());
  61.                 if (res->next()) {
  62.                     thread_id = res->getInt("thread_id");
  63.                     return true;
  64.                 }
  65.             }
  66.             catch (sql::SQLException& e2) {
  67.                 std::cerr << "Query error: " << e2.what() << std::endl;
  68.             }
  69.         }
  71.         std::cerr << "SQLException: " << e.what() << std::endl;
  72.         return false;
  73.     }
  74. }

优点:

  • ✅ 避免死锁
  • ✅ 大部分情况下性能好(只有一次数据库操作)

缺点:

  • ⚠️ 需要唯一索引
  • ⚠️ 依赖异常处理

记录锁死锁分析

image-20251204140931698

  1. bool MysqlDao::AddFriend(const int& from, const int& to, std::string back_name,
  2.     std::vector<std::shared_ptr<AddFriendMsg>>& chat_datas) {
  3.     auto con = pool_->getConnection();
  4.     if (con == nullptr) {
  5.         return false;
  6.     }
  8.     Defer defer([this, &con]() {
  9.         pool_->returnConnection(std::move(con));
  10.         });
  12.     try {
  14.         //开始事务
  15.         con->_con->setAutoCommit(false);
  16.         std::string reverse_back;
  17.         std::string apply_desc;
  19.         {
  20.             // 1. 锁定并读取
  21.             std::unique_ptr<sql::PreparedStatement> selStmt(con->_con->prepareStatement(
  22.                 "SELECT back_name, descs "
  23.                 "FROM friend_apply "
  24.                 "WHERE from_uid = ? AND to_uid = ? "
  25.                 "FOR UPDATE"
  26.             ));
  27.             selStmt->setInt(1, to);
  28.             selStmt->setInt(2, from);
  30.             std::unique_ptr<sql::ResultSet> rsSel(selStmt->executeQuery());
  32.             if (rsSel->next()) {
  33.                 reverse_back = rsSel->getString("back_name");
  34.                 apply_desc = rsSel->getString("descs");
  35.             }
  36.             else {
  37.                 // 没有对应的申请记录，直接 rollback 并返回失败
  38.                 con->_con->rollback();
  39.                 return false;
  40.             }
  41.         }
  43.         {
  44.             // 2. 执行真正的更新
  45.             std::unique_ptr<sql::PreparedStatement> updStmt(con->_con->prepareStatement(
  46.                 "UPDATE friend_apply "
  47.                 "SET status = 1 "
  48.                 "WHERE from_uid = ? AND to_uid = ?"
  49.             ));
  51.             updStmt->setInt(1, to);
  52.             updStmt->setInt(2, from);
  54.             if (updStmt->executeUpdate() != 1) {
  55.                 // 更新行数不对，回滚
  56.                 con->_con->rollback();
  57.                 return false;
  58.             }
  59.         }
  61.         {
  62.             // 3. 准备第一个SQL语句, 插入认证方好友数据
  63.             std::unique_ptr<sql::PreparedStatement> pstmt(con->_con->prepareStatement("INSERT IGNORE INTO friend(self_id, friend_id, back) "
  64.                 "VALUES (?, ?, ?) "
  65.             ));
  66.             //反过来的申请时from，验证时to
  67.             pstmt->setInt(1, from); // from id
  68.             pstmt->setInt(2, to);
  69.             pstmt->setString(3, back_name);
  70.             // 执行更新
  71.             int rowAffected = pstmt->executeUpdate();
  72.             if (rowAffected < 0) {
  73.                 con->_con->rollback();
  74.                 return false;
  75.             }
  77.             //准备第二个SQL语句，插入申请方好友数据
  78.             std::unique_ptr<sql::PreparedStatement> pstmt2(con->_con->prepareStatement("INSERT IGNORE INTO friend(self_id, friend_id, back) "
  79.                 "VALUES (?, ?, ?) "
  80.             ));
  81.             //反过来的申请时from，验证时to
  82.             pstmt2->setInt(1, to); // from id
  83.             pstmt2->setInt(2, from);
  84.             pstmt2->setString(3, reverse_back);
  85.             // 执行更新
  86.             int rowAffected2 = pstmt2->executeUpdate();
  87.             if (rowAffected2 < 0) {
  88.                 con->_con->rollback();
  89.                 return false;
  90.             }
  91.         }
  93.         // 4. 创建 chat_thread
  94.         long long threadId = 0;
  95.         {
  96.             std::unique_ptr<sql::PreparedStatement> threadStmt(con->_con->prepareStatement(
  97.                 "INSERT INTO chat_thread (type, created_at) VALUES ('private', NOW());"
  98.             ));
  100.             threadStmt->executeUpdate();
  102.             std::unique_ptr<sql::Statement> stmt(con->_con->createStatement());
  103.             std::unique_ptr<sql::ResultSet> rs(
  104.                 stmt->executeQuery("SELECT LAST_INSERT_ID()")
  105.             );
  107.             if (rs->next()) {
  108.                 threadId = rs->getInt64(1);
  109.             }
  110.             else {
  111.                 return false;
  112.             }
  113.         }
  115.         // 5. 插入 private_chat
  116.         {
  117.             std::unique_ptr<sql::PreparedStatement> pcStmt(con->_con->prepareStatement(
  118.                 "INSERT INTO private_chat(thread_id, user1_id, user2_id) VALUES (?, ?, ?)"
  119.             ));
  121.             pcStmt->setInt64(1, threadId);
  122.             pcStmt->setInt(2, from);
  123.             pcStmt->setInt(3, to);
  124.             if (pcStmt->executeUpdate() < 0) return false;
  125.         }
  127.         // 6. 可选：插入初始消息到 chat_message
  128.         if (apply_desc.empty() == false)
  129.         {
  130.             std::unique_ptr<sql::PreparedStatement> msgStmt(con->_con->prepareStatement(
  131.                 "INSERT INTO chat_message(thread_id, sender_id, recv_id, content,created_at, updated_at, status) VALUES (?, ?, ?, ?,NOW(),NOW(),?)"
  132.             ));
  134.             msgStmt->setInt64(1, threadId);
  135.             msgStmt->setInt(2, to);
  136.             msgStmt->setInt(3, from);
  137.             msgStmt->setString(4, apply_desc);
  138.             msgStmt->setInt(5, 2);
  139.             if (msgStmt->executeUpdate() < 0) { return false; }
  141.             std::unique_ptr<sql::Statement> stmt(con->_con->createStatement());
  142.             std::unique_ptr<sql::ResultSet> rs(
  143.                 stmt->executeQuery("SELECT LAST_INSERT_ID()")
  144.             );
  145.             if (rs->next()) {
  146.                 auto messageId = rs->getInt64(1);
  147.                 auto tx_data = std::make_shared<AddFriendMsg>();
  148.                 tx_data->set_sender_id(to);
  149.                 tx_data->set_msg_id(messageId);
  150.                 tx_data->set_msgcontent(apply_desc);
  151.                 tx_data->set_thread_id(threadId);
  152.                 tx_data->set_unique_id("");
  153.                 tx_data->set_status(2);
  154.                 std::cout << "addfriend insert message success" << std::endl;
  155.                 chat_datas.push_back(tx_data);
  156.             }
  157.             else {
  158.                 return false;
  159.             }
  160.         }
  162.         {
  163.             std::unique_ptr<sql::PreparedStatement> msgStmt(con->_con->prepareStatement(
  164.                 "INSERT INTO chat_message(thread_id, sender_id, recv_id, content, created_at, updated_at, status) VALUES (?, ?, ?, ?,NOW(),NOW(),?)"
  165.             ));
  167.             msgStmt->setInt64(1, threadId);
  168.             msgStmt->setInt(2, from);
  169.             msgStmt->setInt(3, to);
  170.             msgStmt->setString(4, "We are friends now!");
  172.             msgStmt->setInt(5, 2);
  174.             if (msgStmt->executeUpdate() < 0) { return false; }
  176.             std::unique_ptr<sql::Statement> stmt(con->_con->createStatement());
  177.             std::unique_ptr<sql::ResultSet> rs(
  178.                 stmt->executeQuery("SELECT LAST_INSERT_ID()")
  179.             );
  180.             if (rs->next()) {
  181.                 auto messageId = rs->getInt64(1);
  182.                 auto tx_data = std::make_shared<AddFriendMsg>();
  183.                 tx_data->set_sender_id(from);
  184.                 tx_data->set_msg_id(messageId);
  185.                 tx_data->set_msgcontent("We are friends now!");
  186.                 tx_data->set_thread_id(threadId);
  187.                 tx_data->set_unique_id("");
  188.                 tx_data->set_status(2);
  189.                 chat_datas.push_back(tx_data);
  190.             }
  191.             else {
  192.                 return false;
  193.             }
  194.         }
  196.         // 提交事务
  197.         con->_con->commit();
  198.         std::cout << "addfriend insert friends success" << std::endl;
  200.         return true;
  201.     }
  202.     catch (sql::SQLException& e) {
  203.         // 如果发生错误，回滚事务
  204.         if (con) {
  205.             con->_con->rollback();
  206.         }
  207.         std::cerr << "SQLException: " << e.what();
  208.         std::cerr << " (MySQL error code: " << e.getErrorCode();
  209.         std::cerr << ", SQLState: " << e.getSQLState() << " )" << std::endl;
  210.         return false;
  211.     }
  214.     return true;
  215. }

分析

这段代码死锁的关键点在于同意好友好插入用户顺序不同，导致死锁。

  1. {
  2.             // 3. 准备第一个SQL语句, 插入认证方好友数据
  3.             std::unique_ptr<sql::PreparedStatement> pstmt(con->_con->prepareStatement("INSERT IGNORE INTO friend(self_id, friend_id, back) "
  4.                 "VALUES (?, ?, ?) "
  5.             ));
  6.             //反过来的申请时from，验证时to
  7.             pstmt->setInt(1, from); // from id
  8.             pstmt->setInt(2, to);
  9.             pstmt->setString(3, back_name);
  10.             // 执行更新
  11.             int rowAffected = pstmt->executeUpdate();
  12.             if (rowAffected < 0) {
  13.                 con->_con->rollback();
  14.                 return false;
  15.             }
  17.             //准备第二个SQL语句，插入申请方好友数据
  18.             std::unique_ptr<sql::PreparedStatement> pstmt2(con->_con->prepareStatement("INSERT IGNORE INTO friend(self_id, friend_id, back) "
  19.                 "VALUES (?, ?, ?) "
  20.             ));
  21.             //反过来的申请时from，验证时to
  22.             pstmt2->setInt(1, to); // from id
  23.             pstmt2->setInt(2, from);
  24.             pstmt2->setString(3, reverse_back);
  25.             // 执行更新
  26.             int rowAffected2 = pstmt2->executeUpdate();
  27.             if (rowAffected2 < 0) {
  28.                 con->_con->rollback();
  29.                 return false;
  30.             }
  31.         }

解决方案

保证插入顺序一致即可

  1. bool MysqlDao::AddFriend(const int& from, const int& to, std::string back_name,
  2.     std::vector<std::shared_ptr<AddFriendMsg>>& chat_datas) {
  3.     auto con = pool_->getConnection();
  4.     if (con == nullptr) {
  5.         return false;
  6.     }
  8.     Defer defer([this, &con]() {
  9.         pool_->returnConnection(std::move(con));
  10.         });
  12.     try {
  13.         // 开始事务
  14.         con->_con->setAutoCommit(false);
  15.         std::string reverse_back;
  16.         std::string apply_desc;
  18.         {
  19.             // 1. 锁定并读取
  20.             std::unique_ptr<sql::PreparedStatement> selStmt(con->_con->prepareStatement(
  21.                 "SELECT back_name, descs "
  22.                 "FROM friend_apply "
  23.                 "WHERE from_uid = ? AND to_uid = ? "
  24.                 "FOR UPDATE"
  25.             ));
  26.             selStmt->setInt(1, to);
  27.             selStmt->setInt(2, from);
  29.             std::unique_ptr<sql::ResultSet> rsSel(selStmt->executeQuery());
  31.             if (rsSel->next()) {
  32.                 reverse_back = rsSel->getString("back_name");
  33.                 apply_desc = rsSel->getString("descs");
  34.             }
  35.             else {
  36.                 // 没有对应的申请记录，直接 rollback 并返回失败
  37.                 con->_con->rollback();
  38.                 return false;
  39.             }
  40.         }
  42.         {
  43.             // 2. 执行真正的更新
  44.             std::unique_ptr<sql::PreparedStatement> updStmt(con->_con->prepareStatement(
  45.                 "UPDATE friend_apply "
  46.                 "SET status = 1 "
  47.                 "WHERE from_uid = ? AND to_uid = ?"
  48.             ));
  50.             updStmt->setInt(1, to);
  51.             updStmt->setInt(2, from);
  53.             if (updStmt->executeUpdate() != 1) {
  54.                 // 更新行数不对，回滚
  55.                 con->_con->rollback();
  56.                 return false;
  57.             }
  58.         }
  60.         {
  61.             // 3. 插入好友关系 - 关键改进：按照固定顺序插入避免死锁
  62.             // 确定插入顺序：始终按照 uid 大小顺序
  63.             int smaller_uid = std::min(from, to);
  64.             int larger_uid = std::max(from, to);
  66.             // 第一次插入：较小的 uid 作为 self_id
  67.             std::unique_ptr<sql::PreparedStatement> pstmt(con->_con->prepareStatement(
  68.                 "INSERT IGNORE INTO friend(self_id, friend_id, back) "
  69.                 "VALUES (?, ?, ?)"
  70.             ));
  72.             if (from == smaller_uid) {
  73.                 pstmt->setInt(1, from);
  74.                 pstmt->setInt(2, to);
  75.                 pstmt->setString(3, back_name);
  76.             }
  77.             else {
  78.                 pstmt->setInt(1, to);
  79.                 pstmt->setInt(2, from);
  80.                 pstmt->setString(3, reverse_back);
  81.             }
  83.             int rowAffected = pstmt->executeUpdate();
  84.             if (rowAffected < 0) {
  85.                 con->_con->rollback();
  86.                 return false;
  87.             }
  89.             // 第二次插入：较大的 uid 作为 self_id
  90.             std::unique_ptr<sql::PreparedStatement> pstmt2(con->_con->prepareStatement(
  91.                 "INSERT IGNORE INTO friend(self_id, friend_id, back) "
  92.                 "VALUES (?, ?, ?)"
  93.             ));
  95.             if (from == larger_uid) {
  96.                 pstmt2->setInt(1, from);
  97.                 pstmt2->setInt(2, to);
  98.                 pstmt2->setString(3, back_name);
  99.             }
  100.             else {
  101.                 pstmt2->setInt(1, to);
  102.                 pstmt2->setInt(2, from);
  103.                 pstmt2->setString(3, reverse_back);
  104.             }
  106.             int rowAffected2 = pstmt2->executeUpdate();
  107.             if (rowAffected2 < 0) {
  108.                 con->_con->rollback();
  109.                 return false;
  110.             }
  111.         }
  113.         // 4. 创建 chat_thread
  114.         long long threadId = 0;
  115.         {
  116.             std::unique_ptr<sql::PreparedStatement> threadStmt(con->_con->prepareStatement(
  117.                 "INSERT INTO chat_thread (type, created_at) VALUES ('private', NOW())"
  118.             ));
  120.             threadStmt->executeUpdate();
  122.             std::unique_ptr<sql::Statement> stmt(con->_con->createStatement());
  123.             std::unique_ptr<sql::ResultSet> rs(
  124.                 stmt->executeQuery("SELECT LAST_INSERT_ID()")
  125.             );
  127.             if (rs->next()) {
  128.                 threadId = rs->getInt64(1);
  129.             }
  130.             else {
  131.                 con->_con->rollback();
  132.                 return false;
  133.             }
  134.         }
  136.         // 5. 插入 private_chat
  137.         {
  138.             std::unique_ptr<sql::PreparedStatement> pcStmt(con->_con->prepareStatement(
  139.                 "INSERT INTO private_chat(thread_id, user1_id, user2_id) VALUES (?, ?, ?)"
  140.             ));
  142.             pcStmt->setInt64(1, threadId);
  143.             pcStmt->setInt(2, from);
  144.             pcStmt->setInt(3, to);
  146.             if (pcStmt->executeUpdate() < 0) {
  147.                 con->_con->rollback();
  148.                 return false;
  149.             }
  150.         }
  152.         // 6. 插入初始消息（申请描述）
  153.         if (!apply_desc.empty())
  154.         {
  155.             std::unique_ptr<sql::PreparedStatement> msgStmt(con->_con->prepareStatement(
  156.                 "INSERT INTO chat_message(thread_id, sender_id, recv_id, content, created_at, updated_at, status) "
  157.                 "VALUES (?, ?, ?, ?, NOW(), NOW(), ?)"
  158.             ));
  160.             msgStmt->setInt64(1, threadId);
  161.             msgStmt->setInt(2, to);
  162.             msgStmt->setInt(3, from);
  163.             msgStmt->setString(4, apply_desc);
  164.             msgStmt->setInt(5, 2);
  166.             if (msgStmt->executeUpdate() < 0) {
  167.                 con->_con->rollback();
  168.                 return false;
  169.             }
  171.             std::unique_ptr<sql::Statement> stmt(con->_con->createStatement());
  172.             std::unique_ptr<sql::ResultSet> rs(
  173.                 stmt->executeQuery("SELECT LAST_INSERT_ID()")
  174.             );
  176.             if (rs->next()) {
  177.                 auto messageId = rs->getInt64(1);
  178.                 auto tx_data = std::make_shared<AddFriendMsg>();
  179.                 tx_data->set_sender_id(to);
  180.                 tx_data->set_msg_id(messageId);
  181.                 tx_data->set_msgcontent(apply_desc);
  182.                 tx_data->set_thread_id(threadId);
  183.                 tx_data->set_unique_id("");
  184.                 tx_data->set_status(2);
  185.                 std::cout << "addfriend insert message success" << std::endl;
  186.                 chat_datas.push_back(tx_data);
  187.             }
  188.             else {
  189.                 con->_con->rollback();
  190.                 return false;
  191.             }
  192.         }
  194.         // 7. 插入成为好友的消息
  195.         {
  196.             std::unique_ptr<sql::PreparedStatement> msgStmt(con->_con->prepareStatement(
  197.                 "INSERT INTO chat_message(thread_id, sender_id, recv_id, content, created_at, updated_at, status) "
  198.                 "VALUES (?, ?, ?, ?, NOW(), NOW(), ?)"
  199.             ));
  201.             msgStmt->setInt64(1, threadId);
  202.             msgStmt->setInt(2, from);
  203.             msgStmt->setInt(3, to);
  204.             msgStmt->setString(4, "We are friends now!");
  205.             msgStmt->setInt(5, 2);
  207.             if (msgStmt->executeUpdate() < 0) {
  208.                 con->_con->rollback();
  209.                 return false;
  210.             }
  212.             std::unique_ptr<sql::Statement> stmt(con->_con->createStatement());
  213.             std::unique_ptr<sql::ResultSet> rs(
  214.                 stmt->executeQuery("SELECT LAST_INSERT_ID()")
  215.             );
  217.             if (rs->next()) {
  218.                 auto messageId = rs->getInt64(1);
  219.                 auto tx_data = std::make_shared<AddFriendMsg>();
  220.                 tx_data->set_sender_id(from);
  221.                 tx_data->set_msg_id(messageId);
  222.                 tx_data->set_msgcontent("We are friends now!");
  223.                 tx_data->set_thread_id(threadId);
  224.                 tx_data->set_unique_id("");
  225.                 tx_data->set_status(2);
  226.                 chat_datas.push_back(tx_data);
  227.             }
  228.             else {
  229.                 con->_con->rollback();
  230.                 return false;
  231.             }
  232.         }
  234.         // 提交事务
  235.         con->_con->commit();
  236.         std::cout << "addfriend insert friends success" << std::endl;
  238.         return true;
  239.     }
  240.     catch (sql::SQLException& e) {
  241.         // 如果发生错误，回滚事务
  242.         if (con) {
  243.             con->_con->rollback();
  244.         }
  245.         std::cerr << "SQLException: " << e.what();
  246.         std::cerr << " (MySQL error code: " << e.getErrorCode();
  247.         std::cerr << ", SQLState: " << e.getSQLState() << " )" << std::endl;
  249.         // 如果是死锁错误（1213），可以考虑重试
  250.         if (e.getErrorCode() == 1213) {
  251.             std::cerr << "Deadlock detected, consider retry" << std::endl;
  252.         }
  254.         return false;
  255.     }
  257.     return true;
  258. }
热门评论
点击查看更多评论 没有更多评论了,点击收起 展开评论

热门文章

  1. vscode搭建windows C++开发环境
    喜欢(596) 浏览(100577)

  2. 使用hexo搭建个人博客
    喜欢(533) 浏览(14372)

  3. Linux环境搭建和编码
    喜欢(594) 浏览(15945)

  4. MarkDown在线编辑器
    喜欢(514) 浏览(16295)

  5. 聊天项目(28) 分布式服务通知好友申请
    喜欢(507) 浏览(7367)

最新评论

  1. 解决博客回复区被脚本注入的问题 secondtonone1:走到现在我忽然明白一个道理，无论工作也好生活也罢，最重要的是开心，即使一份安稳的工作不能给我带来事业上的积累也要合理的舍弃，所以我还是想去做喜欢的方向。
  2. 处理网络粘包问题 zyouth: //消息的长度小于头部规定的长度，说明数据未收全，则先将部分消息放到接收节点里 if (bytes_transferred < data_len) { memcpy(_recv_msg_node->_data + _recv_msg_node->_cur_len, _data + copy_len, bytes_transferred); _recv_msg_node->_cur_len += bytes_transferred; ::memset(_data, 0, MAX_LENGTH); _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH), std::bind(&CSession::HandleRead, this, std::placeholders::_1, std::placeholders::_2, shared_self)); //头部处理完成 _b_head_parse = true; return; } 把_b_head_parse = true;放在_socket.async_read_some前面是不是更好
  3. C++ 线程池原理和实现 mzx2023:两种方法解决，一种是改排序算法，就是当线程耗尽的时候，使用普通递归，另一种是当在线程池commit的时候，判断线程是否耗尽，耗尽的话就直接当前线程执行task
  4. 利用指针和容器实现文本查询 越今朝:应该添加一个过滤功能以解决部分单词无法被查询的问题: eg: "I am a teacher."中的teacher无法被查询，因为在示例代码中teacher.被解释为一个单词从而忽略了teacher本身。
  5. 无锁并发队列 TenThousandOne:_head  和 _tail  替换为原子变量。那里pop的逻辑，val = _data[h] 可以移到循环外面吗

其他链接

  1. GitHub
  2. 个人博客
  3. 博客园
  4. CSDN

个人公众号

个人微信