操作系统 / 系统课时

为什么共享内存必须配合同步

为什么共享内存必须配合同步

共享内存的速度来自“多个进程直接访问同一片物理内存”,但这也意味着内核不会替你安排读写先后。本节用单槽生产者消费者模型说明:没有同步时,读者可能看到旧值或半成品;加入进程共享信号量后,数据写入和读取才形成明确时序。

学习目标

  • 能解释共享内存中的数据竞争与读写时序问题
  • 能用生产者消费者模型识别“可写”和“可读”两个状态
  • 能使用进程共享信号量保护一次完整的数据交接

问题不在内存,而在时序

假设生产者把结果写到共享变量 value,消费者随后读取。共享内存只保证双方能访问同一地址对应的数据,不会自动保证“生产者已经写完”这一前提。消费者若过早读取,就可能拿到旧值;双方若同时更新更复杂的数据结构,还可能观察到不一致的中间状态。

单槽缓冲区至少需要两个条件:生产者只能在槽位为空时写,消费者只能在槽位有数据时读。同步原语的任务就是把这两个条件变成可等待、可唤醒的状态,而不是依靠 sleep 猜测时机。

共享内存生产者消费者同步时序

用信号量建立一次可靠交接

下面程序把两个 sem_t 和一个整数一起放进 POSIX 共享内存。sem_init 的第二个参数设为 1,表示信号量可在多个进程之间共享。父进程消费,子进程生产;empty 和 full 共同保证每个值只写一次、只读一次。

c
#include <fcntl.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>

typedef struct {
    sem_t empty;
    sem_t full;
    int value;
} Shared;

int main(void) {
    const char *name = "/anystack-sync-demo";
    int fd = shm_open(name, O_CREAT | O_EXCL | O_RDWR, 0600);
    if (fd == -1) {
        perror("shm_open");
        return EXIT_FAILURE;
    }

    if (ftruncate(fd, (off_t)sizeof(Shared)) == -1) {
        perror("ftruncate");
        close(fd);
        shm_unlink(name);
        return EXIT_FAILURE;
    }

    Shared *shared = mmap(NULL, sizeof(Shared),
                          PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (shared == MAP_FAILED) {
        perror("mmap");
        close(fd);
        shm_unlink(name);
        return EXIT_FAILURE;
    }

    if (sem_init(&shared->empty, 1, 1) == -1 ||
        sem_init(&shared->full, 1, 0) == -1) {
        perror("sem_init");
        munmap(shared, sizeof(Shared));
        close(fd);
        shm_unlink(name);
        return EXIT_FAILURE;
    }

    setvbuf(stdout, NULL, _IONBF, 0);

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return EXIT_FAILURE;
    }

    if (pid == 0) {
        for (int i = 1; i <= 3; ++i) {
            sem_wait(&shared->empty);
            shared->value = i * 10;
            printf("producer: %d\n", shared->value);
            sem_post(&shared->full);
        }
        munmap(shared, sizeof(Shared));
        close(fd);
        _exit(EXIT_SUCCESS);
    }

    for (int i = 1; i <= 3; ++i) {
        sem_wait(&shared->full);
        printf("consumer: %d\n", shared->value);
        sem_post(&shared->empty);
    }

    waitpid(pid, NULL, 0);
    sem_destroy(&shared->empty);
    sem_destroy(&shared->full);
    munmap(shared, sizeof(Shared));
    close(fd);
    shm_unlink(name);
    return EXIT_SUCCESS;
}

预期结果:每次生产之后才允许对应消费,消费完成后才允许下一次覆盖槽位,因此数值按 10、20、30 完整交接。

text
producer: 10
consumer: 10
producer: 20
consumer: 20
producer: 30
consumer: 30

编译并运行:

bash
gcc -Wall -Wextra -O2 shm_sync.c -o shm_sync -pthread -lrt
./shm_sync

预期输出:

text
producer: 10
consumer: 10
producer: 20
consumer: 20
producer: 30
consumer: 30

-pthread 负责启用线程/同步相关的编译与链接设置;在较新的 glibc 上 -lrt 可能不是必需,但保留可兼容更多 Linux 环境。

为什么 sleep 不是同步

把消费者写成“先睡 10 毫秒再读”并不能建立正确性。机器负载、调度延迟和生产者执行时间都可能变化,某次运行看似正常,只代表竞争窗口没有碰巧暴露。真正的同步需要由互斥锁、信号量、条件变量或原子协议表达先后关系。

在上面的单槽模型中,sem_wait(&shared->full) 明确表示“没有成品就等待”,而 sem_post(&shared->full) 表示“写入已经完成,可以读”。这比基于时间的猜测稳定,也能在系统繁忙时自然阻塞而不是反复轮询。

选择同步原语的边界

如果共享区只需要“有一个生产者写完后通知一个消费者”,信号量很直接。若需要保护多个字段的复合更新,可以使用放在共享内存中的进程共享 pthread_mutex_t,并通过 pthread_mutexattr_setpshared 设置 PTHREAD_PROCESS_SHARED。若是环形队列,还需要进一步管理读写索引、满空条件和内存顺序。

共享内存负责“把数据放在双方都能访问的位置”,同步负责“规定双方在什么条件下访问”。只有这两部分同时成立,生产者消费者协议才既快又正确。

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

目录与阅读设置

阅读设置

17

记录一个想法

为什么共享内存必须配合同步

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

登录哪都通