14.5 阶段 4 并发与多线程
所属:全栈开发面试题库 / 学习路径 / 14 C++ 与系统开发
本页目录
一、阶段定位
本阶段解决"多个线程同时干活"。C++ 的并发从 C++11 才进入标准库——之前都是用 pthread 或 Windows API。标准库提供了 std::thread、mutex、condition_variable、atomic、future/promise。但并发也是 C++ 事故高发区:数据竞争、死锁、内存序错误,每一个都能让线上服务随机崩溃。
不掌握本阶段会在后面具体卡在哪:
- 多线程累加一个全局变量,结果总是不对,但单线程跑完全正确——这是数据竞争,你不知道是没加锁还是内存序问题。
- 两个线程互相持有对方需要的锁,程序卡死,GDB 打出栈在
pthread_mutex_lock里——这是死锁。 - 用
std::atomic<int>做计数器,TSan 一跑还是报数据竞争——你不知道原子操作也有内存序问题。 - 写了一个生产者消费者队列,用了 mutex + condition_variable,但消费者永远收不到通知,程序卡在
wait()。
判断自己卡住的标志:(1) 让你说出数据竞争、死锁、活锁的区别,你只能说"多线程出问题";(2) 给一段 ++global_counter 的多线程代码,你看不出问题;(3) 让你用 condition_variable 实现生产者消费者,你写不对 wait(predicate)。出现任一现象,先把本阶段六个模块过一遍再进 阶段 5 系统编程与网络。
二、阶段目标与投入
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
能创建 std::thread,正确 join 或 detach |
程序退出时无泄漏、无崩溃 |
能用 std::mutex + lock_guard/unique_lock 保护共享数据 |
TSan 跑 0 报告 |
| 能用 condition_variable 实现生产者消费者 | 多生产多消费正确同步 |
| 能说明 atomic 与 memory_order 的区别 | 解释 relaxed/acquire/release/seq_cst |
能用 std::async/future 做异步任务 |
任务结果正确获取 |
| 能用 TSan 检测数据竞争并修复 | TSan 报告准确指出位置 |
建议学时:
- 全职(每天 4–6 小时):3 周,约 50–60 小时。其中 thread 与 mutex 12 小时、condition_variable 8 小时、atomic 与内存序 16 小时、future/promise 8 小时、TSan 实战 8 小时、练习 8 小时。
- 在职(每天 2 小时、周末补 4 小时):5–6 周,约 60 小时。
学时分配:thread/mutex 20%、condition_variable 15%、atomic 与内存序 30%、future 10%、TSan 15%、练习 10%。
三、先修自检
| 先修项 | 合格标准 | 不合格时怎么办 |
|---|---|---|
| 阶段 2 内存 | 懂 RAII、智能指针、对象生命周期 | 回到 阶段 2 |
| 操作系统基础 | 知道进程与线程区别、上下文切换 | 补操作系统基础 |
| 阶段 3 STL | 懂 vector、map、算法 | 回到 阶段 3 |
| GDB 基础 | 能用 bt、info threads |
回到 阶段 0 |
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| 线程 | std::thread、join/detach、线程本地存储 thread_local |
会用 | 04.9.3 多线程与原子操作 |
| 互斥 | std::mutex、lock_guard、unique_lock、recursive_mutex、死锁 |
能讲清原理 | 04.9.3 多线程与原子操作 |
| 条件变量 | condition_variable、wait、notify_one、notify_all、谓词 |
会用 | 04.9.3 多线程与原子操作 |
| 原子操作 | std::atomic、memory_order(relaxed/acquire/release/seq_cst)、CAS |
能讲清原理 | 04.9.3 多线程与原子操作 |
| 异步 | std::async、future、promise、shared_future |
会用 | 04.9.3 多线程与原子操作 |
| 检测工具 | TSan(ThreadSanitizer)、数据竞争报告解读 | 会用 | 04.9.5 性能优化与工具链 |
| 操作系统 | 线程调度、上下文切换、CPU 缓存一致性、伪共享 | 了解 | 01.1 操作系统 |
五、分模块精讲
5.1 std::thread 与 join/detach
为什么需要它:多线程并发的基本单位是 std::thread。不会正确管理线程生命周期,要么程序退出时崩(detach 线程访问已析构对象),要么 join 忘记调用导致 std::terminate。
核心机制:
std::thread t(func, args...):启动新线程执行 func。t.join():等待线程结束并回收资源;必须调用,否则析构时std::terminate。t.detach():分离线程,线程在后台跑,资源由运行时回收;危险,主线程退出时 detach 线程也被杀。thread_local:每个线程一份独立副本,常用于日志上下文、随机数种子。- 线程数经验:CPU 密集型 = 核数;IO 密集型可多一些,但不要超过几百。
最小可运行示例:
#include <iostream>
#include <thread>
#include <vector>
void worker(int id) {
std::cout << "worker " << id << " running\n";
}
int main() {
std::vector<std::thread> threads;
for (int i = 0; i < 4; ++i) {
threads.emplace_back(worker, i);
}
for (auto& t : threads) {
t.join(); // 等待所有线程结束
}
std::cout << "all done\n";
return 0;
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
std::terminate 在 thread 析构时 |
没 join 也没 detach | 确保每个 thread 要么 join 要么 detach |
| detach 线程访问已析构对象 | 主线程退出,对象析构 | 避免 detach,或用 join |
| 线程数过多导致卡顿 | 线程切换开销 | 用线程池,限制线程数 |
5.2 mutex 与锁
为什么需要它:多个线程同时写共享数据就会数据竞争。mutex 是最基本的互斥手段。
核心机制:
std::mutex:基本互斥锁;lock()加锁、unlock()解锁;用std::lock_guardRAII 自动解锁。std::unique_lock:更灵活,可以延迟加锁、手动解锁、移动;比lock_guard略重。std::recursive_mutex:同一线程可多次加锁;尽量避免,说明设计有问题。- 死锁:两个线程互相持有对方需要的锁。避免方法:按固定顺序加锁、用
std::lock同时加多个锁、用std::scoped_lock(C++17)。 - 不要在持有锁时做 IO、不要在持有锁时调用未知函数。
最小可运行示例:
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
std::mutex g_mutex;
int g_counter = 0;
void increment() {
for (int i = 0; i < 10000; ++i) {
std::lock_guard<std::mutex> lock(g_mutex); // RAII 自动解锁
++g_counter;
}
}
int main() {
std::vector<std::thread> threads;
for (int i = 0; i < 4; ++i) threads.emplace_back(increment);
for (auto& t : threads) t.join();
std::cout << "counter = " << g_counter << "\n"; // 40000
return 0;
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| counter 结果小于预期 | 数据竞争,++ 不是原子操作 | 加 mutex 或用 atomic |
| 死锁 | 两个线程加锁顺序相反 | 按固定顺序加锁 |
| 持有锁做 IO 导致吞吐低 | 锁粒度太大 | 缩小临界区,只保护共享数据 |
5.3 condition_variable 生产者消费者
为什么需要它:线程之间除了互斥,还需要同步——"我等某个条件满足了再继续"。condition_variable 就是干这个的。
核心机制:
wait(lock, pred):释放锁并等待,被唤醒后重新加锁并检查 pred(防止虚假唤醒)。notify_one():唤醒一个等待者。notify_all():唤醒所有等待者。- 典型模式:生产者往队列放数据后
notify_one;消费者wait直到队列非空。 - 必须用
std::unique_lock(不能用lock_guard),因为 wait 会临时释放锁。
最小可运行示例:
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
std::queue<int> g_queue;
std::mutex g_mutex;
std::condition_variable g_cv;
void producer() {
for (int i = 0; i < 10; ++i) {
{
std::lock_guard<std::mutex> lock(g_mutex);
g_queue.push(i);
}
g_cv.notify_one();
}
}
void consumer() {
while (true) {
std::unique_lock<std::mutex> lock(g_mutex);
g_cv.wait(lock, [] { return !g_queue.empty(); }); // 防止虚假唤醒
int val = g_queue.front();
g_queue.pop();
lock.unlock();
std::cout << "consumed " << val << "\n";
if (val == 9) break;
}
}
int main() {
std::thread p(producer);
std::thread c(consumer);
p.join();
c.join();
return 0;
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 消费者永远卡住 | wait 没加谓词,虚假唤醒 | wait(lock, pred) 必须带谓词 |
| notify 在 wait 之前调用 | 生产者先 notify,消费者还没 wait | notify 不丢失,消费者 wait 时会检查队列 |
| 漏 notify | 条件满足了但没通知 | 放数据后必须 notify |
5.4 atomic 与内存序
为什么需要它:mutex 重(几十纳秒),简单计数器用 atomic 更轻。但 atomic 也有坑——默认 seq_cst 最安全但最慢,relaxed 最快但只能保证原子性不保证顺序。
核心机制:
std::atomic<T>:原子操作,不会被打断;++、--、load()、store()、exchange()、compare_exchange_weak/strong(CAS)。- memory_order:
memory_order_relaxed:只保证原子性,不保证顺序;用于计数器。memory_order_acquire:读操作,之前的写对其他线程可见。memory_order_release:写操作,之前的写对其他线程可见。memory_order_seq_cst:默认,全局顺序一致;最安全但最慢。
- 选型经验:不确定就用默认
seq_cst;计数器用 relaxed;双缓冲用 acquire-release。 - CAS(compare-and-swap):无锁队列、无锁栈的基础。
最小可运行示例:
#include <atomic>
#include <iostream>
#include <thread>
#include <vector>
std::atomic<int> g_counter{0};
void increment() {
for (int i = 0; i < 10000; ++i) {
g_counter.fetch_add(1, std::memory_order_relaxed); // 计数器用 relaxed
}
}
int main() {
std::vector<std::thread> threads;
for (int i = 0; i < 4; ++i) threads.emplace_back(increment);
for (auto& t : threads) t.join();
std::cout << "counter = " << g_counter.load() << "\n"; // 40000
return 0;
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| TSan 报数据竞争 | 以为 atomic 就够了,但复合操作非原子 | 用 mutex 或 CAS 循环 |
| relaxed 导致顺序错乱 | 只保证原子不保证顺序 | 关键路径用 acquire/release |
++atomic 比 mutex 还慢 |
false sharing(伪共享) | 用 alignas(64) 对齐避免缓存行共享 |
5.5 future、promise 与 async
为什么需要它:需要异步任务结果时,用 std::async + future 比手动管 thread + 共享变量简单。
核心机制:
std::async(policy, func, args...):启动异步任务,返回std::future<T>。std::future<T>:get()获取结果(阻塞)、wait()等待、valid()判断是否有结果。std::promise<T>:手动设置结果,set_value()、set_exception();与 future 配对。- policy:
std::launch::async(必须新线程)、std::launch::deferred(延迟到 get 时执行)。
最小可运行示例:
#include <future>
#include <iostream>
int compute(int x) {
return x * x;
}
int main() {
std::future<int> fut = std::async(std::launch::async, compute, 10);
std::cout << "waiting...\n";
int result = fut.get(); // 阻塞直到完成
std::cout << "result = " << result << "\n";
return 0;
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| async 任务没真并行 | 默认 policy 可能是 deferred | 显式 std::launch::async |
| future.get() 抛异常 | 任务函数抛异常 | catch 异常或在 future.get() 处捕获 |
5.6 TSan 检测数据竞争
为什么需要它:数据竞争在 Debug 下可能不出现,在 Release 高并发下随机崩。TSan 能在编译时插桩,运行时精确报告竞争位置。
核心机制:
- 编译加
-fsanitize=thread -g。 - TSan 报告:哪个线程在什么位置读、哪个线程在什么位置写、变量地址。
- TSan 比 ASan 慢 5–15 倍,内存多 5–10 倍,只在测试环境用。
- TSan 不报死锁,死锁用 GDB 看栈。
最小可运行示例:
g++ -g -O0 -fsanitize=thread demo.cpp -o demo_tsan
./demo_tsan
# WARNING: ThreadSanitizer: data race
# Read of size 4 at 0x... by thread T1:
# #0 increment demo.cpp:5
# Previous write of size 4 by thread T2:
# #0 increment demo.cpp:5
六、分层练习
6.1 复现型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 多线程累加 | 4 个线程各加 10000,结果正确 | counter = 40000,TSan 0 报告 | 1 小时 |
| mutex 保护 | 给一个无锁的 counter 加 mutex | 结果正确 | 1 小时 |
| 生产者消费者 | 用 condition_variable 实现 | 10 个数据全部正确消费 | 2 小时 |
| atomic 计数器 | 用 atomic 替代 mutex | TSan 0 报告,性能对比 | 1 小时 |
| async 异步 | 用 std::async 并行算两个任务 | 结果正确获取 | 1 小时 |
6.2 改造型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 修数据竞争 | 故意写一个无锁的多线程代码,TSan 定位修复 | TSan 0 报告 | 1 小时 |
| 修死锁 | 故意写两个线程反向加锁,GDB 定位修复 | 程序正常退出 | 1 小时 |
| 伪共享优化 | 两个 atomic 计数器在同一缓存行,用 alignas 隔离 | TSan 0 报告,性能提升 | 2 小时 |
| 修虚假唤醒 | 给一个没加谓词的 wait,修复 | 消费者不再假醒 | 1 小时 |
6.3 设计型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 实现线程池 | 固定线程数 + 任务队列 + condition_variable | 提交任务正确执行 | 4 小时 |
| 实现无锁队列(单生产者单消费者) | 用 atomic + memory_order | TSan 0 报告,性能对比 mutex 版本 | 4 小时 |
| 整理内存序笔记 | 列出 relaxed/acquire/release/seq_cst 适用场景 | 表格可作为面试速查 | 2 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
| counter 结果小于预期 | 数据竞争,++ 非原子 | TSan 跑复现 | 加 mutex 或 atomic |
| 程序卡死不退出 | 死锁 | GDB bt 看所有线程栈 |
按固定顺序加锁 |
| 消费者永远卡住 | wait 没加谓词 | 看 wait 调用 | wait(lock, pred) |
| TSan 报 data race | 共享变量没保护 | 看报告里的读写位置 | 加锁或 atomic |
| detach 线程崩溃 | 访问已析构对象 | 看崩溃栈 | 避免 detach,用 join |
std::terminate |
thread 没 join 没 detach | 看析构栈 | 确保 join/detach |
| async 没并行 | 默认 deferred | 看 future 行为 | 显式 std::launch::async |
| 多线程慢 | 伪共享或锁粒度太大 | 看 TSan/perf | alignas 对齐,缩小临界区 |
八、出口条件
全部勾选后进入 阶段 5 系统编程与网络。
- [ ] 能创建
std::thread并正确 join,线程退出无泄漏 - [ ] 能用
std::mutex+lock_guard保护共享数据,TSan 0 报告 - [ ] 能用 condition_variable 实现生产者消费者
- [ ] 能说明 atomic 与 memory_order 各选项的区别
- [ ] 能用
std::async/future做异步任务并获取结果 - [ ] 能用 TSan 检测数据竞争并定位修复
- [ ] 能识别死锁并用 GDB 打出所有线程栈定位
自测题:
- 数据竞争与死锁的区别?
- 要点:数据竞争是多线程同时读写共享数据未同步;死锁是多个线程互相持有对方需要的锁而永久阻塞。
lock_guard与unique_lock的区别?- 要点:lock_guard 简单 RAII 不可延迟;unique_lock 可延迟加锁、手动解锁、移动,更灵活但略重。
- condition_variable 的
wait(lock, pred)为什么要带谓词?- 要点:防止虚假唤醒(spurious wakeup),被唤醒后重新检查条件是否真的满足。
- memory_order_relaxed、acquire、release、seq_cst 的区别?
- 要点:relaxed 只保证原子;acquire/release 配对保证可见性;seq_cst 全局顺序一致最安全但最慢。
- CAS 是什么?无锁队列为什么比 mutex 队列快?
- 要点:compare-and-swap 无锁原子操作;无锁避免上下文切换与内核态开销,但实现复杂。
- TSan 报告里 data race 是什么意思?怎么修复?
- 要点:两个线程对同一变量无同步地读写;加 mutex 或用 atomic 保护。