03 · 并发直觉:一条语句、两个线程,八次全不同
咱们写一个短得不能再短的程序:开两个线程,每个线程把同一个全局变量加一百万次。两个线程都干完,这个变量理应是一百万加一百万,两百万。可真跑起来,屏幕上那个数就是到不了两百万,而且一次一个样,八次下来八个不同的答案。笔者照着这个思路,在自己机器上跑了一遍,当场就是这个样子。
咱们手里的东西短得可以当场抄完,可它每次跑出来的数都不一样。会写多线程的人不少,能把这个数为什么不对讲明白的人没那么多,咱们把它摊开看一眼。
两百万的活,两个人干,结果少了一截
咱们把造件写出来,就这么长,一个第三方依赖都没有。
展开代码收起代码共 21 行
#include <cstdio>
#include <cstdlib>
#include <thread>
static long counter = 0;
static const long kLoops = 1000000;
static void worker() {
for (long i = 0; i < kLoops; ++i) {
counter = counter + 1;
}
}
int main(int argc, char **argv) {
int n = (argc > 1) ? std::atoi(argv[1]) : 2;
std::thread t[8];
for (int i = 0; i < n; ++i) t[i] = std::thread(worker);
for (int i = 0; i < n; ++i) t[i].join();
std::printf("counter = %ld (expected %ld)\n", counter, kLoops * n);
return 0;
}咱们把上面这段存成 race.cpp,命令行参数就是线程数,不写就是两个。按最朴素的姿势编出来,老老实实连着跑八次。
$ g++ -O0 -pthread -o race-O0 race.cpp
$ for i in $(seq 8); do ./race-O0 2; donecounter = 1506806 (expected 2000000)
counter = 1010695 (expected 2000000)
counter = 1065935 (expected 2000000)
counter = 1047781 (expected 2000000)
counter = 1049362 (expected 2000000)
counter = 1087182 (expected 2000000)
counter = 1054419 (expected 2000000)
counter = 1034982 (expected 2000000)八行,八个不同的数,没有一个够得着两百万。上面这几行,是笔者从自己机器上这一次跑出来的读数,您那边跑出来的是另外八个,唯一不变的是它们都少。
教科书里有一拍是同一件事,只是它的量级大一些。那边每个线程跑一千万次,期望两千万,书里跑出来是一千九百多万,再跑一次又是一千九百多万。咱们看它原话怎么说的,Not only is each run wrong, but also yields a different result!,每一次都是错的,而且每次还不一样。(OSTEP 第 26 章,书页 8)
窗口只有三条指令
看着不对,咱们就去问编译器到底编出了什么。把 worker 那个函数体反汇编出来,-O0 下最要紧的一段是这样,那一百万次的循环被摊成了下面这几行:
$ objdump -d --no-show-raw-insn -Mintel race-O0 | sed -n '/worker.*>:/,/ret/p'
00000000000011c9 <_ZL6workerv>:
11d7: mov rax,QWORD PTR [rip+0x2e92] # 4070 <_ZL7counter>
11de: add rax,0x1
11e2: mov QWORD PTR [rip+0x2e87],rax # 4070 <_ZL7counter>
11e9: add QWORD PTR [rbp-0x8],0x1
11ee: cmp QWORD PTR [rbp-0x8],0xf423f
11f6: jle 11d7 <_ZL6workerv+0xe>咱们要盯的是头三条:把 counter 从内存读进 rax,在寄存器里加一,再写回内存。完整那一屏是十五行,前面铺栈帧和跳转的四行、后面 nop、nop、pop rbp、ret 四行收尾都省掉了,上面只留了循环主体这六行。咱们在源码里写下的是一个 counter = counter + 1,落到机器上就是这三步。这三步之间,操作系统随时可以把当前线程换下去、把另一个线程换上来。两边都读到同一个旧值,各自加一,各自写回,中间那一次自增就没了。
行首那些十六进制地址是这一次编译和链接布出来的位置,换一次编译就换一套,咱们要看的只是那三条指令本身的形状。
同一份源码,-O2 编出来八次全对
同一个 race.cpp,咱们换成 -O2 再编一份,同样的八次。
$ g++ -O2 -pthread -o race-O2 race.cpp
$ for i in $(seq 8); do ./race-O2 2; donecounter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)八次全是对的。源码一个字没改,两百万安安稳稳地躺在那儿。咱们再把 -O2 编出来的那一版 worker 反汇编出来看:
$ objdump -d --no-show-raw-insn -Mintel race-O2 | sed -n '/worker.*>:/,/ret/p'
00000000000013c0 <_ZL6workerv>:
13c0: add QWORD PTR [rip+0x2ca5],0xf4240 # 4070 <_ZL7counter>
13cb: ret整个函数体只剩一条 add QWORD PTR [rip+0x2ca5],0xf4240,后头一条 ret 就完了。编译器把那一百万次的循环整个折没了,一次加上十六进制的 0xf4240,正好是一百万。刚才那三步的窗口,现在只剩一步。咱们前面数出来的那个空档,不是 counter = counter + 1 生来就有的东西,它是编译器在 -O0 下没做手脚才留下来的。
还有一件事咱们得抠一下:0xf4240 是十六进制,转成十进制就是 1000000,编译器把整个循环折成了“一次加一百万”。
想把错误跑出来,得同时看着三件事
到这里咱们就能回答那个最容易把人绕进去的问题:为什么我抄了同样的代码,跑出来却是对的?
**优化等级。**咱们得确认自己编的时候写的是 -O0。换成 -O2,连窗口都被折掉了,跑多少次都是两百万。
**线程数。**咱们把参数写成了一,那它永远精确,一百万就是一百万,一次都没有错过。两个、四个、八个都错,而且线程越多错得越狠。命令还是 ./race-O0,后面那个参数就是线程数,每档跑三次:
# 1 个线程:
counter = 1000000 (expected 1000000)
counter = 1000000 (expected 1000000)
counter = 1000000 (expected 1000000)
# 2 个线程:
counter = 1041223 (expected 2000000)
counter = 1012069 (expected 2000000)
counter = 1372192 (expected 2000000)
# 4 个线程:
counter = 1158712 (expected 4000000)
counter = 1139674 (expected 4000000)
counter = 1295967 (expected 4000000)
# 8 个线程:
counter = 1758443 (expected 8000000)
counter = 1921508 (expected 8000000)
counter = 1916995 (expected 8000000)八个线程期望八百万,三次落在 1758443 到 1921508 之间,一次都没够着,别的档位也各有各的少法。这几行数和上面那八行一样,都是笔者机器上这一趟的读数。
**CPU 数。**咱们把整个进程按在一个 CPU 上,错误的频率会掉下来,可它没有消失。
$ taskset -c 0 ./race-O0 2counter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)
counter = 1000000 (expected 2000000)
counter = 2000000 (expected 2000000)在这个被按在 0 号 CPU 上的进程里,五次有四次对,有一次是一百万,整整少掉了一个线程的量。您最好别把“按在一个 CPU 上就不复现”当成一条能靠的规律:笔者自己这边把同一份源码编了好几轮,对着它既跑过五次全对的样子,也跑过眼下四次对、一次错的样子。单核上能不能碰见,是概率问题,不是非黑即白。讲并发的那本教科书(OSTEP)里也留给我们一句,even on a single processor, we don't necessarily get the desired result,就算只有一个处理器,我们也不一定拿到想要的结果(第 26 章,书页 8)。
有一点咱们得说明:线程多的时候错得更狠,原因在于同一段时间里重叠的窗口更多,不是因为调度器偏心。调度怎么给线程挑人、隔多久换一次,是操作系统教材里调度章的地盘,咱们在这儿不展开。
锁:把那一行圈起来
修起来短得让人意外:那一行同样的时刻只准一个人进,数就不丢了。咱们把上面那段 race.cpp 复制两份,分别存成 race_locked.cpp 和 race_mutex.cpp,只改几行,别处照旧。
race_locked.cpp 那一版一共动四处:头上加一句 #include <atomic>,把 static long counter = 0; 换成 static std::atomic<long> counter{0};,循环里的自增换成 counter.fetch_add(1, std::memory_order_relaxed);,末尾打印的 counter 换成 counter.load()。咱们按同样的姿势编出新产物:
$ g++ -O0 -pthread -o race_locked-O0 race_locked.cpp$ for i in $(seq 5); do ./race_locked-O0 2; done # std::atomic
counter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)咱们在 race_mutex.cpp 那一版上动三处:头上加 #include <mutex>,在 counter 旁边加一句 static std::mutex m;,循环里用 std::lock_guard<std::mutex> guard(m); 圈住那一行再自增,别的地方与 race.cpp 一模一样。少一句 <mutex>,编译器第一条就报 'mutex' in namespace 'std' does not name a type,接着才轮到 lock_guard 不是 std 的成员,反正编不过。照样编出产物:
$ g++ -O0 -pthread -o race_mutex-O0 race_mutex.cpp$ for i in $(seq 3); do ./race_mutex-O0 2; done # std::mutex
counter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)
counter = 2000000 (expected 2000000)两版都对,而且对得很干脆,每次都报两百万。锁买到的是正确性,但它不白给。同一个两百万次自增,咱们掐了一次表:两条路各跑一次,记下起止时刻再相减。
$ T0=$(date +%s.%N); ./race-O0 2 >/dev/null; T1=$(date +%s.%N)
$ awk -v a="$T0" -v b="$T1" 'BEGIN{printf "race-O0 wall=%.3f s\n", b-a}'
race-O0 wall=0.004 s
$ T0=$(date +%s.%N); ./race_mutex-O0 2 >/dev/null; T1=$(date +%s.%N)
$ awk -v a="$T0" -v b="$T1" 'BEGIN{printf "race_mutex-O0 wall=%.3f s\n", b-a}'
race_mutex-O0 wall=0.102 s两个数字都是笔者从自己机器上掐出来的墙上时间,它随着机器忙闲漂,您那边跑出来的不会一模一样。咱们要读的是那个量级:加了锁慢了二十几倍。这不能读成“锁很慢”,慢的原因是咱们亲手把那一段划成了不能并行的地方,本来两个人一起干的活,现在得排队。
线程在内核眼里,是两条几乎一样的克隆
咱们上面开出来的那些线程,内核那边到底看见了什么?它看见的不是一个人,是好几条一模一样的任务。咱们拿 strace 挂上去,只看克隆这一类系统调用,并且带上 -f 让它跟着子任务走。手册给 -f 的说法是 Traces child processes as they are created,跟着那些刚被创建出来的子任务,少了它就看不到克隆子任务写下的记录。屏里的进程号、counter 那个数、等号后面的地址和长度,都是这一趟跑出来的值,您那边全不一样,咱们要认的是那串 flags 里的名字。
$ strace -f -e trace=clone,clone3 -o clone.trace ./race-O0 2; cat clone.trace
counter = 1283644 (expected 2000000)
386 clone3({flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, child_tid=0x74c57ffffce8, parent_tid=0x74c57ffff990, exit_signal=0, stack=0x74c57f7ff000, stack_size=0x7fff40, tls=0x74c57ffff6c0} => {parent_tid=[387]}, 88) = 387
386 clone3({flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, child_tid=0x74c57f7fece8, parent_tid=0x74c57f7fe990, exit_signal=0, stack=0x74c57effe000, stack_size=0x7fff40, tls=0x74c57f7fe6c0} => {parent_tid=[388]}, 88) = 388
388 +++ exited with 0 +++
387 +++ exited with 0 +++
386 +++ exited with 0 +++strace 把 trace 落到文件里,程序自己那句 counter = ... 打在屏上,再 cat 出来就是上面这一段。咱们开两个线程,就换来两条克隆:两条的 flags 那一串与结尾那个 88 逐字相同,stack_size 也一样,各是各的是 child_tid、parent_tid、stack、tls 这四格,外加返回的那个进程号。flags 那一串名字逐字写着它们共享了什么:CLONE_VM 是地址空间,CLONE_FILES 是已打开文件的表,CLONE_SIGHAND 是信号处理方式,CLONE_THREAD 说明它是同一批线程。
咱们回头接一下前面两篇。上一篇里有一份进程花名册,一个进程号底下只住着一条记录,这会儿屏幕上多出来的正是它的第二条和第三条,同一张名册,换了个看法。再往前那一篇数过一个 hello 的系统调用面,一行一行记下程序跟内核说了哪些话,这里的两行是同一类记录,只是话头换成了给内核递一句“给我再开一条任务”。写完这段咱们得补一句:这一趟抓到的系统调用叫 clone3,是眼下这套 glibc 和内核走的路径,换个版本可能就报 clone。线程和进程共用同一套克隆开关,只是拨到不同的档位上。既然它们共享了地址空间,那就怪不得两个线程会去动同一个 counter。
这一屏只留了克隆这一类系统调用,旁边那些用来协调线程的调用咱们没抓,它们属于锁实现的地盘。
死锁的四个条件
并发里另有一类麻烦叫死锁:两个线程各自捏着一个东西,又都在等对方手里那个,谁都不松手。咱们看到的不是少个数,是程序一直停在那儿。
死锁要同时凑齐下面四条,咱们一条条看:
- 互斥。这个东西同一时刻只准一个人用。
- 持有并等待。手里已经捏着一个,还在等下一个。
- 不可剥夺。别人手里那个你抢不走,只能等他松手。
- 循环等待。等的方向连成了一个圈,甲等乙、乙等甲。
这四条里,咱们只要能拆掉一条,死锁就凑不起来。
这些条件咱们只列到这儿,不做现场。这一篇没有配一段能复现死锁的小程序,笔者也不打算凭印象写一段出来充数。等您在哪天见到一个卡住不动的程序,再回头拿它们四个挨个对。
跑不出错的时候
咱们得替您想到一桩:如果您照着上面抄完,连着跑却次次是两百万,那就回头核那三件事,-O0 写了没有、线程数是不是还停在一、有没有被 taskset 按在单个 CPU 上。这三件都占全了,每一次的错数也还是不同,想抓住它,咱们得多跑几轮。
还有一桩只当量级看:那两行墙上时间是笔者从自己机器上掐出来的。您想自己掐表,time 或者前后各记一次 date 都行,别把别人的数字当成自己机器上的标准。
futex、屏障,和没搭起来的死锁现场
有几样东西咱们得在这儿交代清楚。锁在操作系统内部是怎么落地的,包括追踪线程协调时会出现、咱们这一篇故意没去抓的 futex,一个字都没有讲。屏障和内存顺序同样留着,连 memory_order_relaxed 那个参数咱们都跳了过去,那是编译器和处理器层面的东西。
死锁也只停在四个条件,没有真的搭一个两把锁反序去拿的现场给您看。
调度器怎么在一堆可运行的线程里挑下一个、隔多久换一次人,咱们这一篇只用到“窗口被打开”这件事,挑人那套策略一点没碰。
双视角锚点:同一行代码,两个人读到的不是一回事
咱们让两个人分头来看这一篇里的几件事。
**那一行。**应用程序员写下 counter = counter + 1,在源码里它就是一条语句,他读到的意思是“把 counter 加一”,天经地义。轮到咱们写内核的人,看到的还是上面那三步,而它们之间随时可以换人:-O0 下八次跑出八个不同的数,-O2 下那个空档被编译器折掉,八次全对。应用程序员以为自己写的是一条指令,内核作者知道那是三步。
**那把锁。**应用程序员手上,锁是一个开关,咱们按下去结果就对了,代价是那边慢一点。轮到内核作者,代价换了个名字:咱们是把“这一段不能并行”拿出去换回来的正确性,原本可以同时干的两份活,现在得在门口排队。同一件事,一边看到的是快慢,一边看到的是能并行和不能并行的分别。
**死锁。**应用程序员那边听到死锁,想到的是程序卡住了,重开一次就好。轮到咱们这些写内核的人,卡住是一种结构:四个条件同时在,谁都不肯松开手里那个。同一场停摆,一边看到的是症状,一边看到的是四个能逐个拆掉的支点。
末了收一句。咱们上面开出来的这些线程,落到内核的花名册里是两条并排的记录,它们能同时去动同一个 counter,正因为它们共用了同一张地址空间。