先说脏读。共享内存里放的是一个结构体:版本号、时间戳、若干采样值。写进程先改时间戳,再改数值,中间被操作系统切走;读进程这时读到的时间戳是新的,数值还是上一轮的。更糟的是结构体跨了缓存行,读到一半时另一边正在写,编译器还可能把读重排。没有同步,共享内存就是一块随时会变的公共黑板。

再说管道不返回 EOF。读端用 read() 循环,期望写端关闭后返回 0。但程序 fork 出几个子进程,子进程继承了写端文件描述符却没有关闭,内核认为「还有写端存在」,读端就一直等。文件描述符是引用计数,不是「谁创建谁负责」,这类问题在多进程程序里非常常见。

最后说信号量残留。进程拿到信号量后崩溃,没有执行 sem_post(),计数就少了一个。下一次启动的进程永远等不到,看起来像死锁。信号量只记录计数,不记录「谁拿着」,崩溃不会自动归还;要解决这个问题,得靠带超时的等待、健壮互斥量,或者干脆换成能检测持有者的机制。

本机为 Windows + MinGW,没有 POSIX 的 pipe、shm_open、sem_open、mq_open,这些示例未在本机编译运行,行为按 Linux/POSIX 描述。管道部分用 Windows 的 CreatePipe 做了等价实验,输出为实测,用来验证「所有写端关闭后读端才看到 EOF」这一语义。

先选通信方式

进程之间没有共享的地址空间,所有通信都要经过内核或一块双方都映射的内存。常见方式按「传什么、怎么同步」分成几类。

字节流管道、FIFO、socketpair。适合单向或双向的数据流,内核负责缓冲和阻塞。
共享内存mmap 一段双方都映射的区域。最快,但同步完全自己做。
消息与信号消息队列按条传递,信号量做计数和互斥。适合解耦生产者和消费者。

选择顺序通常是:能用一个进程加线程解决,就别拆进程;必须拆进程,优先用管道或 socketpair 传消息;数据量大、拷贝成本高,才上共享内存;需要跨机器,直接上网络协议。共享内存是最快的,也是最容易写错的,别把它当默认选项。

管道:EOF 是所有写端都关闭

pipe(int fds[2]) 创建一对文件描述符,fds[0] 读、fds[1] 写。它是单向的、内核缓冲的字节流,读写都可能阻塞。读端在「所有写端都关闭」且缓冲为空时返回 0,这就是 EOF;只要还有一个进程握着写端,读端就会继续等。

// POSIX 片段,本机未编译
int fds[2];
if (pipe(fds) != 0) {
  perror("pipe");
  return 1;
}

pid_t pid = fork();
if (pid == 0) {
  close(fds[0]);              // 子进程不用读端,必须关闭
  write(fds[1], "hello", 5);
  close(fds[1]);              // 关闭自己的写端
  _exit(0);
}

close(fds[1]);                // 父进程不用写端,必须关闭
char buf[64];
ssize_t n;
while ((n = read(fds[0], buf, sizeof(buf))) > 0) {
  // 处理数据
}
// n == 0 表示所有写端都关闭了
close(fds[0]);
waitpid(pid, nullptr, 0);

「跑什么、看到什么算通过」:本机用 Windows 的 CreatePipe 做了同样的实验,写线程写入 5 字节后调用 CloseHandle(),读端循环读取。实测输出是 read 5 bytes: hello 和 eof total=5。如果写端不关闭,读端会一直阻塞在 ReadFile(),不会打印 eof。POSIX 上的 read() 语义一致:返回 0 才是结束。

fork 之后每个子进程都有一份描述符副本,必须在不需要的方向上主动 close()。很多「读端不结束」的故障,都是某个后台子进程忘了关写端。排查时用 lsof 看谁还持有这个管道,或者在父子进程里都打印描述符状态。写端没有读者时,写入会触发 SIGPIPE,默认终止进程;服务端通常忽略这个信号,改为检查 write() 的 EPIPE 错误。

FIFO(命名管道)把管道落到文件系统里,用 mkfifo() 创建,不相关的进程也能通过路径打开。阻塞打开时要等双方都到场,任一方没打开,open() 就停住;加 O_NONBLOCK 可以避免卡死,但要处理「暂时没有对方」的情况。FIFO 仍然是字节流,消息边界要自己定。

管道还有两个容易踩的点。一是容量:内核给管道的缓冲区是有限的,Linux 上默认 64 KB 左右,写满之后 write() 会阻塞,直到读端取走一部分。这意味着「先往管道写一大段,再回头读」的写法在小数据上没问题,数据一多就自己把自己锁死:父进程在等管道腾出空间,而唯一能取走数据的正是它自己。二是半双工:普通管道只能单向传,父子要双向通信就建两对,或者直接用 socketpair。写端每次 write 写入的字节数不保证被原子地当成一条消息,读端可能一次读到两次写的内容,协议里必须有长度前缀或分隔符。

共享内存:映射一块双方都能看的区域

POSIX 共享内存的流程是:shm_open() 拿到一个文件描述符,ftruncate() 设定大小,mmap() 把它映射进地址空间,之后就像访问普通内存一样读写。名字以斜杠开头,实际落在 /dev/shm 下;权限和文件一样,创建时给模式。

// POSIX 片段,本机未编译
int fd = shm_open("/demo_shm", O_CREAT | O_RDWR, 0600);
if (fd < 0) { perror("shm_open"); return 1; }
if (ftruncate(fd, 4096) != 0) { perror("ftruncate"); return 1; }

void* p = mmap(nullptr, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (p == MAP_FAILED) { perror("mmap"); return 1; }
close(fd);                     // 映射建立后可以关闭描述符

// 使用 p 指向的内存
int* counter = static_cast<int*>(p);
__atomic_fetch_add(counter, 1, __ATOMIC_SEQ_CST);

munmap(p, 4096);
shm_unlink("/demo_shm");       // 删除名字,已有映射仍然有效

「跑什么、看到什么算通过」:在一个进程里创建并写入,另一个进程用 shm_open 加 O_RDWR 打开同名对象读取,后者应当看到前者的内容。第一个进程执行 shm_unlink() 后,新进程再打开会失败,但已经在映射的进程仍然能访问,直到 munmap()。用 ls /dev/shm 能看到对象,df -h /dev/shm 能看到它占用的是内存还是交换空间。

大小和访问边界要小心。ftruncate() 设的是对象大小,mmap() 按页对齐;访问超出对象大小的地址会触发 SIGBUS,不是普通的段错误。名字也有长度限制,通常几十个字符,太长会失败。对象在重启后消失,因为 /dev/shm 通常是内存文件系统;需要持久化就用普通文件映射,或者把数据落到磁盘。

映射本身不提供任何同步。两个进程同时写同一个位置是数据竞争,读的一方可能看到写了一半的值。共享内存的速度优势,正是建立在「你自己负责同步」这个前提上。

如果数据要跨重启保留,就别用匿名共享内存对象,改成普通文件加 mmap(MAP_SHARED)。这时内存里的修改由内核按自己的节奏写回磁盘,不保证立刻落盘:msync() 能把指定范围刷下去,想在崩溃后还能恢复就得显式调用。反过来,文件被别处 ftruncate 截短之后,已映射区域再访问一样触发 SIGBUS。另外 /dev/shm 的容量由挂载参数决定,常见是内存的一半,容器里往往更小;写满之后 mmap 或写入开始报 ENOSPC,排查时要先看这个限额,而不是怀疑代码。

信号量:计数,不记录持有者

POSIX 命名信号量用 sem_open() 创建或打开,sem_wait() 把计数减一(为零时阻塞),sem_post() 加一。sem_open 的第四个参数是初始值,二值信号量用 1 做互斥,计数信号量用 N 控制并发。

// POSIX 片段,本机未编译
sem_t* sem = sem_open("/demo_sem", O_CREAT, 0600, 1);
if (sem == SEM_FAILED) { perror("sem_open"); return 1; }

sem_wait(sem);                 // 拿锁,计数 1 变 0
// 临界区:读写共享内存
sem_post(sem);                 // 释放,计数 0 变 1

sem_close(sem);
sem_unlink("/demo_sem");       // 删除名字

「跑什么、看到什么算通过」:两个进程各执行一万次「sem_wait、读计数、加一、写回、sem_post」,最终计数应当是两万;去掉信号量再跑,结果会明显偏小。把其中一个进程在 sem_wait 之后直接 kill -9,再启动新进程,新的 sem_wait 会一直阻塞,复现「信号量残留」。

sem_wait() 可能被信号打断,返回 EINTR,循环里要重试。带超时的版本是 sem_timedwait(),超时后返回 -1 并设置 ETIMEDOUT,可以用来做故障恢复:等太久就认为持有者已经死了,记录日志并尝试修复。但这只是猜测,真正的健壮方案是使用带 PTHREAD_MUTEX_ROBUST 的进程共享互斥量,它能告诉下一个加锁者「上一个持有者死了」。

信号量不会因为进程崩溃自动归还。把「拿锁」和「写数据」放在一起时,要考虑崩溃发生在两者之间会留下什么状态;能接受重建就重建,不能接受就设计恢复流程。

还有一种不落名字的用法:sem_init(&sem, 1, 1),第二个参数为 1 表示「进程间共享」,通常把信号量放进一块 mmap(MAP_SHARED | MAP_ANONYMOUS) 的内存里,fork 之后父子都指向它。它比命名信号量少一次文件系统操作,生命周期跟着那块内存走,所有相关进程退出后不会残留,也就不存在「重启后旧信号量还卡着」的问题。代价是无法在不相关的进程之间使用,只能靠 fork 继承。这一点经常被反过来利用:需要跨服务复用的锁用命名信号量,父子内部的临时协作则用匿名的那份。

脏读与双缓冲

共享内存最常见的错误是「写完整个结构再让别人读」,但写本身不是原子的。结构体跨缓存行时,读方可能看到一半新一半旧;即使没跨行,编译器也可能重排读写顺序。解决办法有三类:锁、版本号、双缓冲。

无锁共享的三种做法
互斥量读写都在锁内,简单,代价是串行
序列锁写前后各加一次版本,读两次不一致就重试
双缓冲写备用区,原子切换索引,读方只读稳定区

序列锁(seqlock)适合「写少读多」:写者进入时把版本加一(变成奇数),写完再加一(变成偶数);读者先读版本,读数据,再读版本,若两次不同或为奇数就重读。版本计数用原子操作,数据本身用宽松内存序即可,但读方要在两次版本读之间加 acquire 屏障,防止数据读被重排到版本读之外。

双缓冲则要求两块区域和一个原子索引。写者写当前不活跃的那块,写完后用 release 语义切换索引;读者用 acquire 语义读索引,再读对应区域。它避免了重试,但内存翻倍,而且同一时刻只能有一个写者。选择哪种,取决于数据大小、读写比例和能否接受重试。

这里「release 切换索引」是个具体承诺,不是形容词:写方在切换之前,必须让之前写的数据对其他核可见;读方读到新索引之后,必须能看到那些数据。C++ 里对应 memory_order_release 的 store 和 memory_order_acquire 的 load。用 memory_order_seq_cst 当然也对,但它要求全局统一顺序,多核上会插入额外屏障;用 memory_order_relaxed 则连这个保证都没有,读方可能先看到新索引、再看到旧数据,正好制造出你本想避免的脏读。x86 的强内存模型会让不少错误在开发机上「碰巧不出现」,换到 ARM 或提高优化级别就暴露。

还有一个和同步无关但很伤性能的问题:伪共享。两个进程或两个线程各写自己那个计数器,计数器恰好落在同一条缓存行里,硬件会不停地在核之间搬运这条线,吞吐掉到个位数。解决办法是把热点变量按缓存行对齐、拉开距离,而不是加锁。

消息队列与 socketpair

POSIX 消息队列用 mq_open() 创建,mq_send() 按条发送,mq_receive() 按条接收。它保留消息边界,支持优先级,队列满时发送方可阻塞或返回错误。名字也以斜杠开头,容量和单条大小受系统限制,可以用 mq_getattr() 查。

消息队列适合「生产者快、消费者慢」的解耦:生产方发完就走,消费方按自己的能力取。缺点是数据要经过内核拷贝,量大数据时不如共享内存;队列满时的策略要提前定,是阻塞、丢弃最旧的,还是返回失败让上层重试。

socketpair() 创建一对已连接的本地套接字,双向通信,能直接用 socket 的读写和 poll。它比管道灵活,适合父子进程或同一台机器上的两个服务。消息边界仍然要自己定义,除非用 SOCK_SEQPACKET(并非所有平台都支持)。

socketpair 还有一个管道给不了的能力:Linux 上可以通过 SCM_RIGHTS 把文件描述符发给对端,接收方拿到的是一个真实可用的 fd,不只是编号。很多服务的平滑重启就靠这个:老进程继续持有监听 socket,把新连接交给新进程处理,切换过程中不丢连接。管道做不到,因为它只能传字节,没法传「另一个 fd」。

Windows 上对应什么

Windows 没有 POSIX 的这套名字。CreatePipe() 创建匿名管道,CreateNamedPipe() 创建命名管道;共享内存用 CreateFileMapping() 加 MapViewOfFile(),名字是字符串,句柄关闭前对象一直存在;信号量用 CreateSemaphore(),互斥用 CreateMutex();消息队列没有直接对应,通常用命名管道或本地 socket 模拟。

语义差异也要注意。Windows 的句柄有引用计数,进程退出时内核会回收,但命名对象可能仍然存在;共享内存的删除要在最后一个句柄关闭后,和 POSIX 的 shm_unlink 不完全一样。跨平台代码最好把「创建、映射、同步、清理」封装成统一接口,不要在每个调用点判断平台。

Windows 管道还有个特有的坑:句柄默认可继承。父进程创建管道时如果没把 SECURITY_ATTRIBUTES 里的 bInheritHandle 设成 FALSE,创建子进程时又没清理继承列表,子进程会悄悄拿到写端,读端于是永远等不到 EOF,和 POSIX 上「fork 后忘了关」是同一类故障,只是发生在另一套 API 上。命名对象还要考虑安全描述符:默认权限下别的用户会话可能打不开,服务程序和桌面程序通信时经常卡在这一步。

现象、真实原因、第一步查什么

你看到的现象真实原因第一步查什么
管道读端一直等不到 EOF还有进程持有写端,通常是 fork 后没关闭用 lsof 查谁还打开着这个管道
写管道时进程被信号终止没有读端,触发了 SIGPIPE忽略 SIGPIPE,检查 write() 的 EPIPE
共享内存读到一半新一半旧写入不是原子操作,没有同步是否有锁、序列锁或双缓冲
访问共享内存触发 SIGBUS访问超出对象大小,或映射被截断对象大小、映射长度、写入偏移
信号量在崩溃后永久阻塞持有者没有 sem_post,计数没有归还改用超时等待或健壮互斥量,设计恢复流程
shm_open 打开失败名字不存在、权限不足或名字格式不对名字是否以斜杠开头,/dev/shm 下是否存在
重启后共享内存里的数据消失/dev/shm 是内存文件系统,不持久是否需要持久化,改用文件映射或数据库
消息队列发送阻塞或失败队列满,容量或消息大小受限mq_getattr 看当前容量和上限

边界与代价

  • 共享内存最快,也最危险。没有同步就是数据竞争,出了问题往往偶发、难复现,调试成本远高于多一次拷贝。
  • 管道和消息队列有内核拷贝。大数据量时 CPU 花在复制上,但换来的是现成的同步和阻塞语义,很多场景更划算。
  • 信号量不解决崩溃恢复。它只记计数,不记持有者;需要更强的保证就用健壮互斥量或外部协调。
  • 命名对象需要清理策略。共享内存、信号量、消息队列都会在内核里留名字,异常退出后可能残留,启动时要检测并处理。
  • 跨平台差异大。POSIX 和 Windows 的 API、生命周期、错误码都不同,封装一层比散落判断更省事。

当天能自己验证的练习

  • 写一个父子进程管道:子进程写 5 字节后关闭写端,父进程读到 EOF;再让子进程不关闭写端,观察父进程阻塞。
  • 写两个进程共享一段 mmap 内存,一个写、一个读,不加同步,统计读到不一致的次数;再加信号量对比。
  • 用一个二值信号量保护共享计数器,两个进程各加一万次,核对最终值;中途 kill -9 一个进程,观察下一次启动的行为。
  • 用 shm_open 创建对象,另一个进程打开读取,然后第一个进程 shm_unlink,验证已映射的进程仍能访问、新进程打不开。
  • 用 mq_send/mq_receive 传十条带优先级的消息,观察接收顺序是否按优先级而不是发送顺序。

小结

三句话:管道读端的 EOF 依赖所有写端关闭,fork 后要主动关闭不用的方向;共享内存只提供地址,不提供同步,锁、序列锁、双缓冲至少选一个;信号量只记计数,不记持有者,崩溃恢复要单独设计。

进程间能共享数据了,最后一个问题是共享之后的并发细节:原子操作到底保证什么、内存序怎么选、无锁队列为什么难写对。下一篇讲并发进阶,从 memory_order 讲到 SPSC 环形队列。