当前位置：首页 > news >正文

从 0 开始讲透 C++ 并发（二）：为什么需要 mutex？（数据竞争 + 解决方案）

news 2026/6/4 14:11:44

承接上一篇：
C++并发编程第一篇：线程基础（对标Java，从0讲透）
👉 我们已经学会了：
✔ std::thread 创建线程
✔ lambda 在线程中的使用
✔ join / detach
✔ 生命周期问题

👉 但真正的并发问题，其实刚刚开始

一、问题：多线程同时操作变量会发生什么？

示例

#include <iostream> #include <thread> int main() { int a = 0; std::thread t1([&]{ for(int i = 0; i < 100000; i++) { a++; } }); std::thread t2([&]{ for(int i = 0; i < 100000; i++) { a++; } }); t1.join(); t2.join(); std::cout << a << std::endl; }

你以为： 200000 ❌

👉 实际：

随机值 ❗（比如 137842、189201…）

二、为什么会出错？（核心理解）

👉 关键点：

a++ 不是一个原子操作

👉 实际执行过程：
1️⃣ 读取 a
2️⃣ a + 1
3️⃣ 写回 a

👉 多线程同时执行：

线程1：读 a = 10
线程2：读 a = 10

线程1：写 11
线程2：写 11 ❌（覆盖）

👉 结果：数据丢失 → 最终结果错误

三、问题本质（必须理解🔥）

多个线程同时访问共享资源，并且至少有一个在写 → 就会出问题

👉 核心模型：

共享资源 + 并发写 = 数据竞争

对应第一篇：

线程已经能跑 ✔
但资源没有保护 ❌

四、解决方案：mutex（互斥锁🔥）

👉 思想非常简单：

同一时间，只允许一个线程访问资源

正确写法

#include <iostream> #include <thread> #include <mutex> int main() { int a = 0; std::mutex m; std::thread t1([&]{ for(int i = 0; i < 100000; i++) { std::lock_guard<std::mutex> lock(m); a++; } }); std::thread t2([&]{ for(int i = 0; i < 100000; i++) { std::lock_guard<std::mutex> lock(m); a++; } }); t1.join(); t2.join(); std::cout << a << std::endl; }

👉 输出：200000 ✔

五、lock_guard 是什么？（重点）

std::lock_guard<std::mutex> lock(m);

含义：

构造时加锁
作用域结束自动解锁

本质：

RAII（资源自动管理）

❌ 不推荐写法

m.lock();
a++;
m.unlock();

问题：中途异常 → unlock 不执行 → 死锁 ❗

所以必须用：

lock_guard（标准写法🔥）

六、Java synchronized 对比理解（帮助快速建立认知）

在理解mutex的时候，如果你有 Java 背景，可以这样对比：

Java 写法

synchronized (obj) { a++; }

含义：

进入代码块 → 自动加锁
退出代码块 → 自动释放锁

C++ 写法

std::mutex m; { std::lock_guard<std::mutex> lock(m); a++; }

含义：

lock_guard 构造 → m.lock()
lock_guard 析构 → m.unlock()

解释： std::lock_guard 创建锁，离开作用域，释放锁。

核心对比（必须理解🔥）

维度	Java synchronized	C++ mutex
控制方式	语言级（关键字）	库级（类）
锁绑定	代码块	对象生命周期
自动释放	✔	✔（RAII）
使用方式	简单	更灵活

七、临界区（重要概念🔥）

👉 临界区：

需要被保护的代码区域

👉 示例：

{ std::lock_guard<std::mutex> lock(m); a++; // 临界区 }

原则：临界区越小越好

八、一个常见错误（很多人会踩）

❌ 错误写法

std::lock_guard<std::mutex> lock(m); for(int i = 0; i < 100000; i++) { a++; }

👉 问题：

锁范围太大 → 性能极差

✅ 正确写法

for(...) { std::lock_guard<std::mutex> lock(m); a++; }

九、总结（笔记版）

数据竞争（Data Race）： 原因： 多个线程同时访问共享变量（至少一个写） 问题： a++ 不是原子操作 → 数据错乱 解决： std::mutex + lock_guard 核心： 同一时间只允许一个线程访问 关键概念： 临界区 = 被保护的代码 原则： 锁范围越小越好 必须用 lock_guard（RAII）