同事把日志统计从单线程改成多线程:起 8 个线程,每个处理 100 万行,命中关键词就往全局计数器上加。十次里有两三次结果对不上,两次之间能差几百万。他给计数器加了一把锁,结果立刻正确,耗时却从十几毫秒涨到四百毫秒,比单线程慢了三十倍。
这两个现象几乎覆盖了并发里最常见的坑:不加同步,结果错;加错同步,性能崩。二者都很难在代码评审时看出来——没有语法错误,编译器也不报警,只在特定机器和时序下露头。这篇按「现象、机制、代价」讲一遍:进程和线程共享什么,std::thread 怎么收尾,锁为什么慢、慢在哪,atomic 何时替代锁,条件变量为什么必须带谓词,竞争为何换个编译选项就「好了」,死锁又该怎么查。
先看结果为什么对不上
把同事那段逻辑缩成最小版本:一个全局变量,8 个线程各加 100 万次。
#include <iostream>
#include <thread>
#include <vector>
long long counter = 0;
void worker() {
for (int i = 0; i < 1000000; ++i) {
++counter;
}
}
int main() {
std::vector<std::thread> pool;
for (int i = 0; i < 8; ++i) {
pool.emplace_back(worker);
}
for (auto& t : pool) {
t.join();
}
const long long expected = 8LL * 1000000;
std::cout << "expected=" << expected << " got=" << counter << "\n";
std::cout << "lost=" << (expected - counter) << "\n";
return 0;
}
g++ -std=c++20 -Wall -Wextra -O0 race.cpp -o race0.exe
在本机 -O0 下连跑三次,三次全错,输出(每次都不一样):
expected=8000000 got=2868540
lost=5131460
expected=8000000 got=1694187
lost=6305813
expected=8000000 got=2673701
lost=5326299
正确结果必然是 800 万,三次却分别少了 513 万、630 万、532 万。少的不是「算错」,是「算丢」。原因在 ++counter:它落到机器层面是读内存、寄存器加一、写回内存三步。两个线程若在这三步中间交错,就会各自读到 800,各自写回 801,两次加法只留下一次结果。
这里三次全错,是因为 -O0 让每次读改写都落到内存,竞争窗口最大;换个构建方式,失败率会变,后面第八节会看到反例。
这叫数据竞争:两个线程同时访问同一块内存,至少一个写,且没有同步。在 C++ 标准里它是未定义行为,不只是「偶尔算错」,编译器有权假设它不存在并据此优化。所以这类 bug 要按「程序已经不可信」处理。
进程和线程,资源上差在哪
进程拥有一块独立的地址空间、一张文件描述符表和一组线程;线程是同一进程里的执行流,共享地址空间和文件描述符表,自己只有寄存器、栈和 thread_local 变量。所以线程间传数据极便宜,指针一递就行;代价是一个线程越界写坏堆,整个进程一起崩,没有隔离。
| 维度 | 进程 | 线程 |
|---|---|---|
| 地址空间 | 各自独立 | 共享堆、全局和静态变量 |
| 文件描述符 | 各自一张表 | 共享一张,一处 close 全体受影响 |
| 创建开销 | 建页表、复制状态,重 | 只分配栈和登记调度,轻 |
| 通信 | 管道、socket,要显式建立 | 直接读写同一块内存 |
| 故障影响 | 通常只死自己 | 整个进程退出 |
| 适用场景 | 要隔离、跑第三方代码 | 同一份数据并行算、同时等多个 I/O |
还有两点常被忽略:线程栈有默认大小(Linux 常见 8MB,Windows 常见 1MB),开几百个线程光栈就吃掉大量虚拟内存;线程调度由系统决定,代码里先写 t1 后写 t2,不代表 t1 先跑或先跑完。后面讲条件变量和死锁都会用到这一点。
完整走查:把串行统计改成并行
需求是统计两百万行日志里含 ERROR 的行数。串行版本二十毫秒左右,想利用多核,就把行区间切开,每段交给一个 std::async 任务,最后把各段结果加起来。
#include <chrono>
#include <cstddef>
#include <future>
#include <functional>
#include <iostream>
#include <string>
#include <thread>
#include <vector>
// 只读一段区间,返回命中的行数,不碰任何共享变量
std::size_t count_range(const std::vector<std::string>& lines,
std::size_t begin, std::size_t end) {
std::size_t n = 0;
for (std::size_t i = begin; i < end; ++i) {
if (lines[i].find("ERROR") != std::string::npos) {
++n;
}
}
return n;
}
int main() {
std::vector<std::string> lines;
lines.reserve(2000000);
for (int i = 0; i < 2000000; ++i) {
if (i % 7 == 0) {
lines.emplace_back("2026-01-01 ERROR disk full");
} else {
lines.emplace_back("2026-01-01 INFO heartbeat ok");
}
}
const std::size_t total = lines.size();
std::cout << "hardware_concurrency=" << std::thread::hardware_concurrency() << "\n";
for (unsigned workers : {1u, 2u, 4u, 8u, 16u}) {
auto t0 = std::chrono::steady_clock::now();
std::vector<std::future<std::size_t>> jobs;
const std::size_t chunk = total / workers;
for (unsigned k = 0; k < workers; ++k) {
const std::size_t b = k * chunk;
const std::size_t e = (k + 1 == workers) ? total : b + chunk;
jobs.push_back(std::async(std::launch::async, count_range,
std::cref(lines), b, e));
}
std::size_t sum = 0;
for (auto& f : jobs) {
sum += f.get(); // 阻塞到该任务结束,异常也会在这里抛出
}
const auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now() - t0).count();
std::cout << "workers=" << workers << " errors=" << sum
<< " ms=" << ms << "\n";
}
return 0;
}
g++ -std=c++20 -Wall -Wextra -O2 scan.cpp -o scan.exe
.\scan.exe
本机一次运行的输出:
hardware_concurrency=12
workers=1 errors=285715 ms=21
workers=2 errors=285715 ms=12
workers=4 errors=285715 ms=9
workers=8 errors=285715 ms=7
workers=16 errors=285715 ms=6
先看正确性:每 7 行有 1 行 ERROR,正确值就是 285715,五种线程数全对。因为 count_range 只读输入、只返回局部计数,结果经 future 交回主线程累加,全程没有共享的可写变量——没有共享,就没有竞争。
再看性能:1 个线程 21ms,4 个 9ms,8 个 7ms,16 个 6ms,本机 hardware_concurrency 是 12。收益不线性,原因有三:线程创建回收要时间;这段活主要受内存带宽限制;计时只到毫秒,抖动占比不小。
两个细节值得记:std::launch::async 写死是要求立刻开线程,不写的话标准允许拖到 get() 才执行,就没有并行了;std::cref(lines) 是为了传引用而不是把两百万字符串拷八份,前提是 lines 活到所有 get() 之后。
std::thread:创建之后必须收尾
#include <iostream>
#include <thread>
void hello(int id) {
std::cout << "worker " << id << " running\n";
}
int main() {
std::thread t(hello, 1); // 立刻开始执行,参数按值传给 hello
t.join();
std::cout << "main done\n";
return 0;
}
本机输出 worker 1 running 和 main done 两行。构造函数一返回,新线程就已经在跑,没有「稍后启动」。join() 阻塞到目标线程结束,detach() 把它和对象脱钩。
规则很硬:std::thread 析构时必须已经 join 或 detach,两者都没做,标准规定直接 std::terminate。本机把 t.join() 删掉后,进程退出码是 3,libstdc++ 打印 terminate called without an active exception,后面的清理代码一行都没执行。
detach 也不省心。把局部字符串的引用传给分离线程,本机只打印了 main returns immediately,线程自己的输出没出现——main 返回后进程结束,分离线程被掐断。如果它跑到一半、对象已销毁,就变成访问悬垂引用。
C++20 的 std::jthread 把收尾自动化:析构自动 join,并附带 stop_token 请求停止。下面这段本机输出 worker stopped, ticks=4(数字随负载变):
#include <chrono>
#include <iostream>
#include <stop_token>
#include <thread>
int main() {
std::jthread worker([](std::stop_token st) {
int tick = 0;
while (!st.stop_requested()) {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
++tick;
}
std::cout << "worker stopped, ticks=" << tick << "\n";
});
std::this_thread::sleep_for(std::chrono::milliseconds(35));
worker.request_stop();
return 0;
}
request_stop() 只是「请求」,不会打断 sleep_for;线程要睡醒、回到循环顶部检查 stop_requested() 才退出。这就是协作式取消:停止点得自己写,好处是线程能把手上这段活干完再走。
join:函数中间抛异常,join 那行没执行到,栈展开时 std::thread 析构,进程直接终止。用 jthread 或自己包一层 RAII 可以避免。锁:为什么加了反而更慢
#include <mutex>
long long counter = 0;
std::mutex m;
void worker() {
for (int i = 0; i < 1000000; ++i) {
std::lock_guard<std::mutex> lk(m); // 构造加锁,析构解锁
++counter;
}
}
结果确实精确是 800 万,但看耗时(本机 -O0,同一台机器跑两次):
| 写法 | 总耗时 | 结果 |
|---|---|---|
| 单线程直接加 800 万次 | 13 ms | 8000000 |
| 8 线程,每次自增都加锁 | 399–491 ms | 8000000 |
| 8 线程,各自本地累加,最后一次合并 | 1 ms | 8000000 |
8 线程,fetch_add | 130–133 ms | 8000000 |
第二行就是「加了锁反而更慢」:8 个核并行干一件必须排队的事,排队成了瓶颈。每次加解锁都是原子操作,8 个线程争同一把锁,锁所在的缓存行在核间来回搬,抢不到的还要进内核挂起再唤醒。临界区里只有一条自增,锁的开销比活大几十倍,「并行」变成「轮流」,还多付调度费。
第三行是正解:每个线程先在栈上用自己的局部变量累加,互不相干,最后只加一次锁合并。锁从 800 万次降到 8 次,耗时 1 毫秒。原则是临界区尽量小,加锁次数尽量少。
三个工具分工不同:lock_guard 最简单,只能构造锁、析构放;unique_lock 可手动 unlock/lock,条件变量必须配它;scoped_lock(C++17)一次锁多个互斥量,内部做了防死锁处理。
atomic 与 memory_order:什么时候不用锁
共享的只是一个整数或标志位时,配一把互斥量太重。std::atomic 保证读写和加减是原子的,不会读到「加了一半」的值。
#include <atomic>
std::atomic<long long> counter{0};
void worker() {
for (int i = 0; i < 1000000; ++i) {
counter.fetch_add(1, std::memory_order_relaxed);
}
}
本机 8 线程各 100 万次,耗时 130 毫秒左右,结果精确 800 万。它比每次加锁快,但仍比「本地累加再合并」慢两个数量级,因为 8 个线程还在抢同一条缓存行,只是粒度比互斥量小。
mutex 保护一组状态
多个字段必须一起变,比如队列头尾指针、余额和流水。临界区里可以写多条语句,读也一起锁住,逻辑清楚。
atomic 保护一个值
计数器、开关、指针这类单值,用原子操作。省掉锁对象,也不会漏掉某条读路径;但不能拿它拼复杂逻辑,两个原子变量之间没有一致性保证。
第二个参数是内存序,控制操作前后的普通读写能否被重排到另一边。默认 seq_cst 最严格;relaxed 只保证自身原子,适合纯计数;acquire/release 成对使用,用来做「写完数据再置标志」的发布—订阅。
本机实测 relaxed 与 seq_cst 耗时几乎一样(98–109 ms 对 101–107 ms),因为 x86 的原子加都是同一条带 lock 前缀的指令,差别主要出现在 ARM 这类弱内存序架构。别拿「本机测不出」当理由乱省内存序,没把握就用默认值。
volatile 不是同步手段。它只让编译器别把读优化掉,不提供原子性,也不建立线程间顺序。用 volatile bool 当停止标志,在标准 C++ 里仍然是数据竞争。condition_variable:别用 sleep 轮询
消费者不知道什么时候有活,最省事的写法是 while (queue.empty()) sleep(10ms);。它既空转占 CPU,又让平均延迟多出几毫秒;生产者结束后还可能永远转下去。正确工具是条件变量:拿不到活就挂起,被通知再醒。
#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
std::mutex m;
std::condition_variable cv;
std::queue<int> q;
bool done = false;
void producer() {
for (int i = 1; i <= 10; ++i) {
{
std::lock_guard<std::mutex> lk(m);
q.push(i);
}
cv.notify_one();
std::this_thread::sleep_for(std::chrono::milliseconds(2));
}
{
std::lock_guard<std::mutex> lk(m);
done = true;
}
cv.notify_all();
}
void consumer(int id) {
while (true) {
std::unique_lock<std::mutex> lk(m);
cv.wait(lk, [] { return !q.empty() || done; });
if (q.empty()) {
return;
}
int v = q.front();
q.pop();
lk.unlock();
std::cout << "consumer " << id << " got " << v << "\n";
}
}
本机输出(谁拿到哪个数每次不同,这里只是一次的样子):
consumer 2 got 1
consumer 2 got 2
consumer 1 got 3
consumer 2 got 4
consumer 1 got 5
consumer 2 got 6
consumer 1 got 7
consumer 2 got 8
consumer 1 got 9
consumer 2 got 10
queue_empty=0
wait(lk, 谓词) 的语义是「释放锁、挂起;被唤醒后重新拿锁并检查谓词,不成立就继续等」。谓词不是装饰,它挡两件事:虚假唤醒(系统没通知也可能唤醒)和丢通知(通知发生在你挂起之前)。notify_one 叫醒一个,notify_all 叫醒全部;生产者结束必须用 notify_all,否则另一个消费者会一直睡。
顺序上,改状态要在锁内,notify 可以放锁外,减少「刚被叫醒又被锁挡住」。消费者拿到数据立刻 unlock,再做打印这种慢操作,别占着锁干活。
为什么这个 bug 换个编译选项就好了
同一段无锁计数代码用 -O2 编译,本机连跑三次全是 expected=8000000 got=8000000。只看这个结果,很容易得出「代码没问题,是 -O0 的锅」,而它恰好是反的。
原因在优化:-O2 把 100 万次自增折叠成一次加法,或把 counter 缓存在寄存器里到最后才写回,循环从一百万次读改写变成一两条指令;而创建 8 个线程本身要几百微秒,第一个线程很可能干完活时后面的还没启动。真正重叠的窗口没了,竞争自然没发生。这不是程序变对,是踩中了更小的概率。
这类 bug 有三个特征:和时序有关,加一行 cout 或一次 sleep,节奏一变就消失或变必现;和机器有关,开发机 8 核不复现,2 核测试机反而必现;和优化等级有关,Release 版「看起来正常」只是症状被藏得更深。
最有效的查法是 ThreadSanitizer(-fsanitize=thread),它记录每次内存访问的线程和锁,能直接报出冲突的两行。本机 MinGW 上 GCC 的 TSAN 运行时不完整,本文未实测;Linux 上配合 -g 比较可靠。没有它时,把所有共享可写变量列出来逐个问「谁写、谁读、靠什么保证顺序」,再用高并发压测放大窗口。
死锁:四个条件与排查顺序
经典形态是两把锁、两个线程、相反顺序。下面这段本机编译通过,但不要直接运行——它会挂住:
#include <chrono>
#include <mutex>
#include <thread>
std::mutex m1;
std::mutex m2;
void a_to_b() {
std::lock_guard<std::mutex> lk1(m1);
std::this_thread::sleep_for(std::chrono::milliseconds(1));
std::lock_guard<std::mutex> lk2(m2); // 等 m2
}
void b_to_a() {
std::lock_guard<std::mutex> lk2(m2);
std::this_thread::sleep_for(std::chrono::milliseconds(1));
std::lock_guard<std::mutex> lk1(m1); // 等 m1
}
A 拿着 m1 等 m2,B 拿着 m2 等 m1,谁也不放手。死锁有四个必要条件:互斥、占有并等待、不可抢占、循环等待,缺一不可,所以破掉任何一个就能防住。
工程上最实用的是破「循环等待」:所有锁定一个全局顺序,线程都按同样顺序拿;或者用 std::scoped_lock(m1, m2) 一次锁两把。其次是破「占有并等待」:拿不到第二把就放掉第一把,过会儿重试,即 try_lock 配超时,代价是要处理重试和活锁。
已经卡住时,先确认是死锁不是慢:CPU 接近 0、日志停在某行、线程数不变。Linux 上用 gdb attach 后 thread apply all bt,Windows 上抓 dump 看各线程栈,找「谁持哪把锁、又在等哪把」,再对照代码的加锁顺序。别在没有栈的情况下猜。
线程开多少,以及伪共享
本机 std::thread::hardware_concurrency() 返回 12,上一节的测试也印证:4 个线程收益最明显,8 个、16 个只多省一两毫秒。规则大致是:纯计算按物理核数配;带阻塞 I/O 的可以多开;混合负载先按核数配,再用线程池排队,别按请求数无限开线程。
伪共享是另一个容易忽略的点:CPU 按 64 字节的缓存行读写,两个线程各改一个独立变量,只要它们落在同一行,硬件仍认为在共享,一方写就让另一方缓存失效,来回弹。表现是「逻辑上没有共享,性能却像有锁」。修法是给每个线程的计数器加 alignas(64) 或用填充隔开。它在每秒百万次以上的高频写入时才明显,普通业务不用提前防。
现象、原因、先查什么
并发问题最耗时间的不是修,是定位。按「看到什么」分流,比通读代码有效。
| 你看到的现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 结果偶尔少一点,十次错两三次,重跑又对 | 数据竞争:共享变量没同步,自增被覆盖 | 列出跨线程读写的变量,逐个问谁写;用 TSAN 或压测放大窗口 |
一启动就 abort,提示 terminate called without an active exception | std::thread 析构时既没 join 也没 detach | 查线程对象的生命周期,尤其异常分支和提前 return 的路径 |
| 加锁后结果对了,但比单线程慢几倍到几十倍 | 锁争用:临界区太长,或每轮都加解锁 | 数加锁次数,能本地累加的先算完,最后只同步一次 |
| 进程卡住不退出,CPU 接近 0,日志停住 | 死锁,或条件变量丢通知、等错谓词 | 抓所有线程栈,看谁持锁、谁在等锁;检查 notify_all 是否漏了 |
| CPU 跑满但吞吐不涨,加线程更慢 | 线程数超过核数,或伪共享、自旋等待 | 对比 hardware_concurrency 和实际线程数;看是否在写相邻变量 |
| 偶发崩溃在后台线程,栈指向已释放对象 | detach 后线程还在访问局部变量 | 查 detach 前捕获了什么,确认对象活得比线程久 |
| 数据看着对,但偶尔读到旧值 | 缺 release/acquire 配对,或误用 relaxed | 检查发布数据的原子变量用的内存序,先改回默认的 seq_cst 对比 |
最值得记的是第一行和最后一行:它们不崩、不报错,只让数据悄悄错掉,测试大概率测不出来。遇到「偶尔对不上」先假设是竞争,别先怀疑硬件。
边界与代价
并发不是免费的加速键,用之前得知道它在哪里收钱。
- 创建和切换有成本。任务粒度太小时,建线程的开销比活还大,这时该用线程池。
- 调试难度上一个台阶。断点会改变时序,bug 可能就此消失;日志互相穿插,最好带线程 id。
- 正确性靠人保证。语言不检查数据竞争,漏锁一条读路径就是埋雷;能不用共享状态就不用,往往比精巧的锁结构可靠。
- 平台与规模有上限。同一份
std::thread代码,不同工具链的调度和栈大小不同;几百个线程之后,异步 I/O、协程或线程池比继续加线程更合适。
但多线程也有不可替代的场合:同一份内存要并行算,或一个程序要同时等多个慢操作。关键不是回避,而是知道共享了什么、靠什么保证顺序、出问题从哪儿查。
当天能验证的练习
- 把第一段的无锁计数程序建好,
-O0连跑五次并记录got;再把线程数改成 2、4、8,看丢失量怎么变。 - 同一源文件用
-O0和-O2各编译一次,各跑十次统计错误次数,想清楚-O2全对能否证明代码正确。 - 把「每次都加锁」改成「本地累加、最后合并」,用
steady_clock测两种写法的耗时。 - 写一个
jthread,让它在循环里查stop_token,主线程 50 毫秒后request_stop();再把检查换成sleep_for(1s),观察停止要等多久。 - 把生产者—消费者里的
wait(lk, 谓词)改成不带谓词的wait(lk),多跑几次,看是否出现消费者拿到空队列或提前退出。
小结
记三句话:线程共享地址空间,传数据便宜,但一个越界全进程陪葬;共享的可写变量必须有同步,++counter 不是一步是三步;锁的代价在争用,减少加锁次数比换更快的锁有用。
程序内部的并行到这里能写对了。再往下一层,就是程序怎么跟操作系统打交道:文件怎么打开、进程怎么创建、管道怎么接、为什么服务跑久了会报 Too many open files。下一篇从 POSIX 系统调用讲起。