C / C++ / 系统课时

使用 POSIX 共享内存

使用 POSIX 共享内存

POSIX 共享内存让多个进程把同一个内核内存对象映射进各自地址空间,避免通过管道重复拷贝大块数据。本课用 shm_open、ftruncate 与 mmap 建立共享区,并用进程共享信号量证明数据共享仍需独立同步。

学习目标

  • 能创建、定长并映射 POSIX 共享内存对象,理解名称、文件描述符和映射区的生命周期。
  • 能让另一个进程重新打开同名对象,并通过 MAP_SHARED 观察共享数据。
  • 能使用进程共享同步原语协调读写顺序,避免把“可见”误认为“并发安全”。

从名称到映射要经过三步

shm_open 先在 POSIX 共享内存命名空间创建或打开对象,并返回文件描述符;新对象初始长度通常为 0,所以写入前要用 ftruncate 设定大小;随后 mmap(..., MAP_SHARED, ...) 把该对象映射进进程地址空间。映射成功后即可关闭文件描述符,映射本身仍然有效。

共享内存名称通常形如 /anystack_shm_1234:以 / 开头,并为不同任务选用不会碰撞的名字。对象权限受 mode 与进程 umask 共同影响。另一个进程只要以兼容权限 shm_open 同名对象,再按相同布局映射,就能访问同一组字节。

POSIX 共享内存对象、映射与同步关系

主示例同时验证共享与同步

下面程序先创建共享内存,把一个 sem_t 和消息缓冲区放进共享区域。fork 后子进程故意解除继承的映射,再通过同一个名称重新 shm_open 和 mmap,从而模拟独立进程重新接入。父进程写完消息后执行 sem_post,子进程必须通过 sem_wait 才读取。

c
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>

struct shared_block {
    sem_t ready;
    char message[128];
};

static void die(const char *msg) {
    perror(msg);
    exit(EXIT_FAILURE);
}

int main(void) {
    setvbuf(stdout, NULL, _IONBF, 0);

    char name[64];
    snprintf(name, sizeof name, "/anystack_shm_%ld", (long)getpid());

    int fd = shm_open(name, O_CREAT | O_EXCL | O_RDWR, 0600);
    if (fd == -1) {
        die("shm_open");
    }

    if (ftruncate(fd, (off_t)sizeof(struct shared_block)) == -1) {
        die("ftruncate");
    }

    struct shared_block *shared =
        mmap(NULL, sizeof *shared, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (shared == MAP_FAILED) {
        die("mmap");
    }
    close(fd);  // mmap 成功后,不再需要保留这个描述符

    if (sem_init(&shared->ready, 1, 0) == -1) {
        die("sem_init");
    }

    pid_t pid = fork();
    if (pid == -1) {
        die("fork");
    }

    if (pid == 0) {
        munmap(shared, sizeof *shared);  // 不依赖 fork 继承的旧映射

        int child_fd = shm_open(name, O_RDWR, 0);
        if (child_fd == -1) {
            die("child shm_open");
        }

        struct shared_block *child =
            mmap(NULL, sizeof *child, PROT_READ | PROT_WRITE,
                 MAP_SHARED, child_fd, 0);
        if (child == MAP_FAILED) {
            die("child mmap");
        }
        close(child_fd);

        while (sem_wait(&child->ready) == -1) {
            if (errno != EINTR) {
                die("sem_wait");
            }
        }

        printf("child read: %s\n", child->message);
        munmap(child, sizeof *child);
        return EXIT_SUCCESS;
    }

    snprintf(shared->message, sizeof shared->message,
             "hello from shared memory");
    printf("parent wrote: %s\n", shared->message);

    if (sem_post(&shared->ready) == -1) {
        die("sem_post");
    }

    waitpid(pid, NULL, 0);
    sem_destroy(&shared->ready);
    munmap(shared, sizeof *shared);
    shm_unlink(name);
    return EXIT_SUCCESS;
}

保存为 shm_demo.c,在 Linux 上编译并运行:

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

预期输出:

text
parent wrote: hello from shared memory
child read: hello from shared memory

-lrt 对较新的 glibc 往往不再是必需项,但保留它可兼容仍把部分 POSIX 实时接口放在 librt 中的较老 Linux 环境。

共享可见性不等于并发安全

MAP_SHARED 解决的是“多个映射是否指向同一个底层对象”,并不自动解决“谁先写、谁后读”。如果两个进程同时修改普通 C 对象却没有合适的同步协议,就可能读到不一致状态;对 C 语言层面的并发访问,还要遵守所用同步原语和数据类型的内存顺序要求。

示例把 sem_t 也放在共享映射里,并用 sem_init(..., 1, 0) 的第二个参数 1 指定进程共享。实际工程还可以选择进程共享的 pthread_mutex_t、信号量或经过严格设计的原子协议,但同步对象自身也必须满足跨进程使用条件。

大小、映射标志与销毁时机

必须在访问映射范围前确保共享内存对象足够大。若对象实际长度小于要访问的映射页,越过对象末尾访问可能触发 SIGBUS。需要共享修改时使用 MAP_SHARED;误用 MAP_PRIVATE 会产生写时复制,其他进程看不到你的私有修改。

shm_unlink 只删除名称,语义类似普通文件的 unlink:已经存在的映射不会立刻失效,底层对象会在名称被删除且最后一个引用消失后释放。因此常见生命周期是“创建并映射 → 各进程使用 → 全部完成同步 → munmap/关闭 → 由约定的一方 shm_unlink”。

对于大块、频繁交换的数据,共享内存通常比把内容复制进管道更合适;但它把消息边界、互斥、版本兼容和崩溃恢复都交给应用协议。先把共享布局和同步规则写清楚,再追求零拷贝带来的性能收益。

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

目录与阅读设置

阅读设置

17

记录一个想法

使用 POSIX 共享内存

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

登录哪都通