几块不同的地址空间里,同一个结构体落在同一个物理页上——这就是用 mmap 做进程间通信(IPC,inter-process communication)的全部基础。

三段进程地址空间通过 mmap 接到同一块物理内存,共享区里放着一把锁、一个条件变量和一段缓冲区

光有共享内存不够。两个进程同时往同一块缓冲区里写,和两个线程同时改一个 int 没有区别,最后还得靠互斥量和条件变量来排队。难点在于:这两个东西默认只在一个进程内部有效。

锁得先被声明成"进程间共享"

pthread_mutex_t 默认的属性是 PTHREAD_PROCESS_PRIVATE,意思是"只在本进程的线程之间协调"。把它放进共享内存只是换了个存放位置,属性没变,另一个进程拿着它对同一块内存加锁,协调行为是未定义的。条件变量同理。

要跨进程,初始化时必须带上属性对象,条件变量照同样的路子走:

pthread_mutexattr_t mattr;
pthread_mutexattr_init(&mattr);
pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
pthread_mutex_init(&lock, &mattr);
pthread_mutexattr_destroy(&mattr);

这也解释了为什么共享区里的锁不能用 PTHREAD_MUTEX_INITIALIZER:那个宏只能给出默认属性,没法带 pshared。整块共享结构因此长成一份头文件:

#pragma once
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <pthread.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
 
#define SHM_NAME "/bit_shm"
 
class SafeObj
{
public:
    pthread_mutex_t lock;
    pthread_cond_t cond;
    char buffer[4096];
 
    void Init()
    {
        pthread_mutexattr_t mattr;
        pthread_mutexattr_init(&mattr);
        pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
        pthread_mutex_init(&lock, &mattr);
        pthread_mutexattr_destroy(&mattr);
 
        pthread_condattr_t cattr;
        pthread_condattr_init(&cattr);
        pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_SHARED);
        pthread_cond_init(&cond, &cattr);
        pthread_condattr_destroy(&cattr);
 
        memset(buffer, 0, sizeof(buffer));
    }
 
    void Set(const std::string &in)
    {
        memset(buffer, 0, sizeof(buffer));
        strncpy(buffer, in.c_str(), sizeof(buffer) - 1);
    }
    std::string Get() { return std::string(buffer); }
};
 
#define SHM_SIZE sizeof(SafeObj)
 
inline void *MapCreate()
{
    int fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
    if (fd < 0) { perror("shm_open"); exit(1); }
    if (ftruncate(fd, SHM_SIZE) < 0) { perror("ftruncate"); exit(2); }
    void *addr = mmap(nullptr, SHM_SIZE, PROT_READ | PROT_WRITE,
                      MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) { perror("mmap"); exit(3); }
    close(fd);
    return addr;
}
 
inline void *MapAttach()
{
    int fd = shm_open(SHM_NAME, O_RDWR, 0666);
    if (fd < 0) { perror("shm_open"); exit(4); }
    void *addr = mmap(nullptr, SHM_SIZE, PROT_READ | PROT_WRITE,
                      MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) { perror("mmap"); exit(5); }
    close(fd);
    return addr;
}

SafeObj 的构造函数是空的,Init 要单独调用,原因绕不开:这块内存是 mmap 直接铺出来的,C++ 的构造函数根本不会在那上面跑。不是编译器漏了,是构造语义只对 new、栈对象、静态对象成立。所有成员都得手工初始化——包括那把锁。

还有一点容易忽略:Init 只能执行一次。它后面是一个已经初始化的互斥量时,pthread_mutex_init 会覆盖一块正在被使用的内存,结果是未定义。这份代码里只让服务端调 Init,客户端只 MapAttach。课件把加锁、解锁、等待、广播一并包成了 SafeObj 的 LockObj、UnlockObj、Wait、BroadCast,读写缓冲区则是 GetContent/SetContent;包一层与直接调 pthread_* 等价,这里展开写只是为了看清每一次锁的进出。

shm_open 给共享内存取名字,mmap 不关心名字

课件在这段注释里写的是"映射的文件,必须以 / 开头,这是 mmap 的约定"。这句话的归属错了:mmap 收的是文件描述符,从不看名字;取名规则属于 shm_open(3),手册写的是"/somename 的形式,以斜杠开头,后面不含斜杠,总长不超过 NAME_MAX(255)"。O_CREAT 时不满足这个形式会返回 EINVAL。

shm_open 创建的对象不是磁盘文件,它挂在 tmpfs 上,没有目录项,行为却像文件:有描述符、能被 ftruncate、能被 mmap、能被 unlink。名字只是进程之间找到同一个对象的凭据。

顺序上有个必须遵守的次序:先 ftruncate,再 mmap 访问。新建的共享内存对象长度是 0,mmap 会成功,第一次读写的那个页却在对象末尾之外,收到的是 SIGBUS。服务端先跑没问题,它做了 ftruncate;课件里的客户端也带着 O_CREAT,它要是先跑起来,就会把对象建成长度 0,再照着 sizeof(SafeObj) 映射,结果是一访问就崩。下面这份客户端改成不带 O_CREAT 的 O_RDWR,对象不存在时直接报 ENOENT,比 SIGBUS 好排查得多。两个进程也因此必须使用同一份头文件,两边的 SHM_SIZE 和结构体布局必须完全一致。

shm_open 打开成功之后立刻 close(fd) 是安全的:映射本身持有一份引用,文件名被 shm_unlink 删掉也不影响已经建立映射的进程。这就是服务端可以在退出时 shm_unlink 而其他进程照常运行的原因。

广播,而不是通知一个

服务端 fork 出若干个子进程,每个都在条件变量上等一条消息;客户端从标准输入读一行,写进共享缓冲区并发信号。课件 fork 了十个子进程,下面的版本缩到三个,结构不变。

#include "SharedMem.hpp"
#include <sys/wait.h>
 
int main()
{
    SafeObj *obj = static_cast<SafeObj *>(MapCreate());
    obj->Init();
 
    for (int i = 0; i < 3; i++) {
        if (fork() == 0) {
            std::string me = "process-" + std::to_string(i);
            printf("%s running\n", me.c_str());
            while (true) {
                pthread_mutex_lock(&obj->lock);
                pthread_cond_wait(&obj->cond, &obj->lock);
                std::string msg = obj->Get();
                pthread_mutex_unlock(&obj->lock);
 
                printf("%s got %s\n", me.c_str(), msg.c_str());
                if (msg == "end")
                    break;
            }
            _exit(0);
        }
    }
 
    while (wait(nullptr) > 0) { }
    shm_unlink(SHM_NAME);
    return 0;
}
#include "SharedMem.hpp"
 
int main()
{
    SafeObj *obj = static_cast<SafeObj *>(MapAttach());
    std::string line;
 
    while (std::getline(std::cin, line)) {
        pthread_mutex_lock(&obj->lock);
        obj->Set(line);
        pthread_cond_broadcast(&obj->cond);
        pthread_mutex_unlock(&obj->lock);
        if (line == "end")
            break;
    }
    return 0;
}

这里必须用 pthread_cond_broadcast 而不是 signal。等待者有三个,消息内容才是"该谁动"的依据,signal 唤醒的那一个未必是收取者。课件把它叫"把他们全部叫醒,让他们自己判断",就是这个意思:广播是"有事发生",过滤在用户态做。

每个子进程醒来后按名字判断要不要动,收到 end 时全部退出

广播带来一个结构性限制:缓冲区只有一份,被覆盖的风险一直存在。消息 A 唤醒了进程 0,但在它拿到锁之前,客户端又写了消息 B,进程 0 醒来读到的就是 B。要保证每条消息都送达,得把 buffer 换成队列,或者加一个"已消费"标记,让发送方等待读取完成——那已经是另一层协议,不是 mmap 能替你解决的。

还有个细节:这里每个等待者只用 if 判断有没有事做,没有 while 重查条件。因为这一版的条件就是"缓冲区里有新内容",而每次醒来都要读一遍,读到的内容由名字匹配决定是否打印,所以重复醒来并不出错。换成"队列非空才取"这类会改变状态的条件,while 就必须回来。

匿名映射只在有亲缘关系的进程之间成立

fork 出来的子进程会继承父进程的映射,所以只要映射是 MAP_SHARED | MAP_ANONYMOUS,父子之间不需要任何文件就能共享一块内存:

#include <stdio.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>
#include <semaphore.h>
 
struct Shared {
    sem_t sem;
    int value;
};
 
int main(void)
{
    struct Shared *s = mmap(NULL, sizeof(*s), PROT_READ | PROT_WRITE,
                            MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (s == MAP_FAILED) {
        perror("mmap");
        return 1;
    }
 
    sem_init(&s->sem, 1, 0);        /* pshared 非 0:进程间共享 */
 
    pid_t pid = fork();
    if (pid == 0) {
        s->value = 42;
        sem_post(&s->sem);
        _exit(0);
    }
 
    sem_wait(&s->sem);
    printf("%d\n", s->value);       /* 42 */
 
    waitpid(pid, NULL, 0);
    sem_destroy(&s->sem);
    munmap(s, sizeof(*s));
    return 0;
}

两个标志缺一不可。只写 MAP_ANONYMOUS、用 MAP_PRIVATE 的话,父子各持一份写时复制的页,子进程改的值父进程看不到;只写 MAP_SHARED 却没有文件描述符,mmap 直接报错。sem_init 的第二个参数同理,传 0 是把信号量当成线程私有的计数器,跨进程用没有意义。

mmap 的长度传 sizeof(*s) 而不是凑成 4096,这里没有页对齐要求,内核会按页补齐。匿名映射的局限也很清楚:它没有名字,只存在于 fork 之前建立的映射关系里。两个互不相识、各自被 shell 启动的进程,只能靠共享内存对象或文件映射来相遇。

编译这两个程序需要 -pthread;老版本 glibc 里 shm_open 在 librt,还要加 -lrt(新版本已并入 libc,加上也无害):

all: server client
 
server: Server.cc
	g++ -o $@ $^ -std=c++17 -pthread -lrt
 
client: Client.cc
	g++ -o $@ $^ -std=c++17 -pthread -lrt
 
.PHONY: clean
clean:
	rm -f server client