罗罗编程学习记录 全栈面试题库
本页导航 展开查看

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_guard RAII 自动解锁。
  • 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 打出所有线程栈定位

自测题:

  1. 数据竞争与死锁的区别?
    • 要点:数据竞争是多线程同时读写共享数据未同步;死锁是多个线程互相持有对方需要的锁而永久阻塞。
  2. lock_guard 与 unique_lock 的区别?
    • 要点:lock_guard 简单 RAII 不可延迟;unique_lock 可延迟加锁、手动解锁、移动,更灵活但略重。
  3. condition_variable 的 wait(lock, pred) 为什么要带谓词?
    • 要点:防止虚假唤醒(spurious wakeup),被唤醒后重新检查条件是否真的满足。
  4. memory_order_relaxed、acquire、release、seq_cst 的区别?
    • 要点:relaxed 只保证原子;acquire/release 配对保证可见性;seq_cst 全局顺序一致最安全但最慢。
  5. CAS 是什么?无锁队列为什么比 mutex 队列快?
    • 要点:compare-and-swap 无锁原子操作;无锁避免上下文切换与内核态开销,但实现复杂。
  6. TSan 报告里 data race 是什么意思?怎么修复?
    • 要点:两个线程对同一变量无同步地读写;加 mutex 或用 atomic 保护。