C / C++ / 系统课时
两个进程同时修改会怎样
两个进程同时修改会怎样
共享内存让进程间交换数据非常快,但“共享”不等于“安全”。当两个或更多进程同时对同一个计数器执行读、加一、写回时,这组操作可能彼此穿插,最终结果小于理论值,这就是典型的丢失更新与并发竞争。
学习目标
- 能通过共享计数器复现并发修改导致的丢失更新
- 能解释
counter++为什么不是一个不可分割的原子操作 - 能判断何时必须引入互斥、信号量或原子读改写
先观察共享计数器
下面程序用匿名 MAP_SHARED 映射保存计数器,创建 4 个子进程,每个子进程递增 500000 次。管道只负责让多个子进程尽量同时开始,计数器本身没有任何同步保护。
#define _DEFAULT_SOURCE
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>
enum {
WORKERS = 4,
INCREMENTS = 500000
};
int main(void) {
volatile uint64_t *counter = mmap(
NULL,
sizeof(*counter),
PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS,
-1,
0
);
if (counter == MAP_FAILED) {
perror("mmap");
return 1;
}
*counter = 0;
int gate[2];
if (pipe(gate) < 0) {
perror("pipe");
munmap((void *)counter, sizeof(*counter));
return 1;
}
for (int i = 0; i < WORKERS; ++i) {
pid_t pid = fork();
if (pid < 0) {
perror("fork");
return 1;
}
if (pid == 0) {
close(gate[1]);
char token;
if (read(gate[0], &token, 1) != 1) {
_exit(2);
}
for (int n = 0; n < INCREMENTS; ++n) {
(*counter)++;
}
close(gate[0]);
_exit(0);
}
}
close(gate[0]);
char tokens[WORKERS];
for (int i = 0; i < WORKERS; ++i) {
tokens[i] = 'x';
}
if (write(gate[1], tokens, sizeof(tokens)) != sizeof(tokens)) {
perror("write");
return 1;
}
close(gate[1]);
for (int i = 0; i < WORKERS; ++i) {
if (wait(NULL) < 0) {
perror("wait");
return 1;
}
}
uint64_t expected = (uint64_t)WORKERS * INCREMENTS;
printf("expected=%" PRIu64 "\n", expected);
printf("actual=%" PRIu64 "\n", *counter);
munmap((void *)counter, sizeof(*counter));
return 0;
}预期结果:理论值固定为 2000000;由于递增不是原子读改写,actual 在多数有并发重叠的运行中会小于理论值,但具体数值受调度与硬件影响,不能预先写死。
cc -std=c11 -Wall -Wextra -O2 race_counter.c -o race_counter
for i in 1 2 3; do ./race_counter; done预期输出
expected=2000000
actual=<ACTUAL_1>
expected=2000000
actual=<ACTUAL_2>
expected=2000000
actual=<ACTUAL_3><ACTUAL_1> 到 <ACTUAL_3> 是每次运行的动态值,通常会变化。极少数调度情况下也可能恰好得到 2000000,因此判断是否存在竞争不能只看某一次输出。
丢失更新是怎么发生的
表达式 (*counter)++ 看起来是一行 C 代码,但处理器通常需要完成“读取旧值、计算新值、写回”这几个阶段。若两个进程都在写回前读到了同一个旧值,它们就可能写回同一个新值。

关键点在于:缓存一致性只能帮助多个 CPU 核心看到彼此的内存写入,并不会把“读、加、写”自动合并成一个不可分割操作。两个写入都是真实发生的,但其中一次递增效果被后一次写回覆盖了。
为什么每次结果都可能不同
并发程序的指令交错由调度器、CPU 核心数量、时间片和运行负载共同影响。某次运行中两个进程可能频繁交错,丢失大量更新;另一次运行可能大部分时间错开执行,结果就更接近理论值。
因此,竞态测试的目标不是得到某个固定错误数字,而是证明“正确性依赖了不可控的执行顺序”。只要程序需要在所有合法调度下都得到准确计数,就不能接受这种实现。
需要准确结果时怎么做
共享计数器必须把“读取并更新”变成受保护或原子的操作。POSIX 进程间常见选择包括把 pthread_mutex_t 放进共享内存并设置 PTHREAD_PROCESS_SHARED、使用进程共享信号量,或在明确支持的平台上使用真正的原子读改写操作。
选择原则取决于临界区大小:只更新一个整数时,原子操作通常最轻;需要同时维护多个字段或保持复杂不变量时,互斥锁更容易保证整体一致性。无论采用哪种机制,都应再次运行同样的并发压力测试,并把验收条件改成 actual 在每次运行中都严格等于 2000000。