同事把日志统计从单线程改成多线程:起 8 个线程,每个处理 100 万行,命中关键词就往全局计数器上加。十次里有两三次结果对不上,两次之间能差几百万。他给计数器加了一把锁,结果立刻正确,耗时却从十几毫秒涨到四百毫秒,比单线程慢了三十倍。

这两个现象几乎覆盖了并发里最常见的坑:不加同步,结果错;加错同步,性能崩。二者都很难在代码评审时看出来——没有语法错误,编译器也不报警,只在特定机器和时序下露头。这篇按「现象、机制、代价」讲一遍:进程和线程共享什么,std::thread 怎么收尾,锁为什么慢、慢在哪,atomic 何时替代锁,条件变量为什么必须带谓词,竞争为何换个编译选项就「好了」,死锁又该怎么查。

本文按 C++20 写,示例在本机 Windows + MinGW g++ 16.2.0 上实际编译运行过。文中耗时和计数都是真实跑出来的,但每次运行的具体数字会变,竞争类尤其大——看量级和趋势,不要记绝对值。

先看结果为什么对不上

把同事那段逻辑缩成最小版本:一个全局变量,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 ms8000000
8 线程,每次自增都加锁399–491 ms8000000
8 线程,各自本地累加,最后一次合并1 ms8000000
8 线程,fetch_add130–133 ms8000000

第二行就是「加了锁反而更慢」:8 个核并行干一件必须排队的事,排队成了瓶颈。每次加解锁都是原子操作,8 个线程争同一把锁,锁所在的缓存行在核间来回搬,抢不到的还要进内核挂起再唤醒。临界区里只有一条自增,锁的开销比活大几十倍,「并行」变成「轮流」,还多付调度费。

第三行是正解:每个线程先在栈上用自己的局部变量累加,互不相干,最后只加一次锁合并。锁从 800 万次降到 8 次,耗时 1 毫秒。原则是临界区尽量小,加锁次数尽量少。

三个工具分工不同:lock_guard 最简单,只能构造锁、析构放;unique_lock 可手动 unlock/lock,条件变量必须配它;scoped_lock(C++17)一次锁多个互斥量,内部做了防死锁处理。

别把大段逻辑塞进临界区。锁里做 I/O、等网络、打印日志,都会把别的线程一起拖住;在锁里调用外部回调更危险,你不知道对方会不会反过来再拿一把锁。

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 exceptionstd::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 系统调用讲起。