C / C++ / 系统课时

两个进程同时修改会怎样

两个进程同时修改会怎样

共享内存让进程间交换数据非常快,但“共享”不等于“安全”。当两个或更多进程同时对同一个计数器执行读、加一、写回时,这组操作可能彼此穿插,最终结果小于理论值,这就是典型的丢失更新与并发竞争。

学习目标

  • 能通过共享计数器复现并发修改导致的丢失更新
  • 能解释 counter++ 为什么不是一个不可分割的原子操作
  • 能判断何时必须引入互斥、信号量或原子读改写

先观察共享计数器

下面程序用匿名 MAP_SHARED 映射保存计数器,创建 4 个子进程,每个子进程递增 500000 次。管道只负责让多个子进程尽量同时开始,计数器本身没有任何同步保护。

c
#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 在多数有并发重叠的运行中会小于理论值,但具体数值受调度与硬件影响,不能预先写死。

bash
cc -std=c11 -Wall -Wextra -O2 race_counter.c -o race_counter
for i in 1 2 3; do ./race_counter; done

预期输出

text
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。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

两个进程同时修改会怎样

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通