有一个监控进程和一个处理进程,都要读同一份 200 MB 的字典。最直接的做法是各自读一遍文件:内存翻倍,启动慢,更新时还要两边同步。用 TCP 或者管道传过去也不划算:要序列化、要拷贝、要解析,200 MB 的数据在本地回环上也要走一趟内核。共享内存就是为这种场景准备的:同一块物理内存,同时映射进两个进程的地址空间,谁改了另一边立刻能看到,没有拷贝。

但共享内存只解决「同一块字节」,不解决「谁先写、谁后读」。它把并发问题从线程层搬到了进程层,难度只增不减。而且 Rust 标准库没有共享内存 API,也没有 Unix socket 的跨平台封装,这些能力要直接对着操作系统接口写。这一篇先把模型讲清,再用一个在 Windows 上真跑通的父子进程例子,最后说明 Unix socket 的适用边界。

先分清两条路:传数据还是共享数据

进程间通信大致分两类。第一类是「传消息」:管道、TCP、Unix socket、消息队列,本质是把一段数据从 A 的地址空间复制到内核,再复制到 B。简单、隔离好,但大块数据要付出两次拷贝。第二类是「共享数据」:共享内存、内存映射文件,两个进程映射同一块物理页,读写不经过内核拷贝,代价是必须自己做同步。

传消息

边界清楚,进程崩溃不会带坏对方;适合请求响应、事件通知、小数据。每次都有拷贝和系统调用开销。

共享内存

零拷贝,适合大块只读数据或高频读写;但同步、生命周期、崩溃恢复全要自己处理。

选哪种不是看「哪个更快」,而是看数据形态。200 MB 只读字典适合共享内存;每秒几千条小消息适合 socket;一次性的配置传递用管道就够了。把大文件硬塞进 socket,或者用共享内存传一条 10 字节的指令,都是把工具用错了地方。

共享内存长什么样

操作系统给每个进程一个独立的虚拟地址空间。共享内存的做法是:创建一块「命名或匿名的内存对象」,两个进程各自调用映射接口,把那块物理页映射到自己的地址空间里。之后 A 往自己的地址写,B 从自己的地址读,看到的是同一份数据。两个进程里的虚拟地址通常不同,但指向的物理页相同。

同一块物理页,两个地址空间
进程 A 的虚拟地址
同一块物理内存
进程 B 的虚拟地址

这块内存在哪里、叫什么名字、活多久,由操作系统决定。Windows 上是「文件映射对象」,可以命名,名字在会话或全局命名空间里可见;Unix 上是 shm_open 创建的 POSIX 共享内存对象,或者直接用 mmap 映射一个普通文件。两者都能做到「进程 A 写、进程 B 读」,API 完全不同。

Windows 实测:命名共享内存

标准库没有这层封装,只能声明 Win32 函数。下面这段在本机 Windows 上实际编译运行过:父进程创建名为 Local\rust_doc_lab_shm 的映射,写入两个计数器,然后启动子进程;子进程用 OpenFileMappingW 打开同名对象,把第二个计数器加 100;父进程等子进程结束后读回结果。

#[link(name = "kernel32")]
extern "system" {
    fn CreateFileMappingW(file: *mut c_void, attrs: *mut c_void, protect: u32,
        size_high: u32, size_low: u32, name: *const u16) -> *mut c_void;
    fn OpenFileMappingW(access: u32, inherit: i32, name: *const u16) -> *mut c_void;
    fn MapViewOfFile(handle: *mut c_void, access: u32, offset_high: u32,
        offset_low: u32, view_size: usize) -> *mut c_void;
    fn UnmapViewOfFile(addr: *const c_void) -> i32;
    fn CloseHandle(handle: *mut c_void) -> i32;
}

父进程创建映射并映射视图,把偏移 0 和偏移 8 当作两个 u64 计数器;子进程打开同名映射,用 read_volatile/write_volatile 读写。实际输出:

parent    => initialized, own=1, child=0
child     => saw before=0, wrote 100, now=100
parent    => after child, own=1, child=100

三行输出对应三个事实:父进程初始化后看到自己的计数为 1;子进程打开时看到了父进程写的初始值 0,说明两边确实是同一块内存;子进程加完 100 后,父进程读到了 100,不需要任何消息传递。

几个容易踩的细节。第一,名字前缀 Local\ 表示只在当前登录会话可见,Global\ 跨会话但通常需要更高权限;不加前缀时默认落在会话命名空间。第二,CreateFileMappingW 的第一个参数传 null 表示「用分页文件支撑」,不落盘;传文件句柄则是把文件映射进内存,两种语义要分清。第三,映射视图用完必须 UnmapViewOfFile,句柄必须 CloseHandle,否则资源泄漏。第四,所有指针操作都在 unsafe 里,越界、对齐错误、悬垂指针都由你自己负责。

Local\ 命名空间里的对象默认允许同会话的其他进程打开。名字一旦被别人猜到,对方就能读写这块内存。共享内存不适合放密钥、令牌这类敏感数据;真要放,得配合访问控制或改用受保护的通道。

共享内存不解决同步

上面那个例子里,父进程等子进程退出后才读结果,天然有先后关系,所以不需要锁。如果两个进程同时读写同一块区域,问题立刻出现:子进程可能读到父进程写了一半的结构体,父进程可能覆盖子进程刚写的数据。共享内存只提供「同一块地址」,不提供任何顺序保证。

read_volatile/write_volatile 只阻止编译器把读写优化掉或重排,不保证 CPU 层面的顺序,也不保证操作是原子的。一个对齐的 u64 在 x86-64 上单次读写通常不会撕裂,但这是平台行为,不是 Rust 的承诺。跨平台、跨架构的代码不能依赖这个「通常」。

正确的做法是把同步原语也放进共享内存,或者用操作系统提供的跨进程同步对象。Windows 上有命名 Mutex、Semaphore、Event;Unix 上有 POSIX 信号量、pthread_mutex 的进程共享属性。std::sync::Mutex 不能跨进程用,它内部依赖进程私有的状态。另一个选择是把 AtomicU64 放在共享内存里,用原子操作做简单的计数或标志位,但前提是目标平台支持无锁的 64 位原子操作,并且地址对齐正确。这段没有在本机做跨进程原子测试,只说明方向。

设计上还有一条经验:共享内存里的结构尽量设计成「单写多读」或「分区写」。一个进程负责写某一块,另一个进程只读,或者每个进程写自己的区域,最后再合并。这样能把同步范围压到最小,减少锁和内存屏障的使用。反过来,两个进程频繁改同一个链表,无论用什么锁都会很难调。

Unix 上的对应做法

Unix 没有 CreateFileMappingW,对应的是 POSIX 共享内存:shm_open 创建或打开一个命名对象,ftruncate 设置大小,mmap 映射到地址空间,用完 munmap,最后 shm_unlink 删除名字。shm_open 的名字以斜杠开头,比如 /my_cache,但它不是文件系统里的真实路径,而是共享内存命名空间里的名字。

Rust 标准库不提供 mmap,要用 libc 直接调,或者引入 memmap2 这类封装库。下面这段是示意,未在本机实测:

let fd = libc::shm_open(name.as_ptr(), libc::O_CREAT | libc::O_RDWR, 0o600);
libc::ftruncate(fd, size as i64);
let ptr = libc::mmap(std::ptr::null_mut(), size,
    libc::PROT_READ | libc::PROT_WRITE, libc::MAP_SHARED, fd, 0);

注意 MAP_SHARED:用 MAP_PRIVATE 会变成写时复制,两个进程看到的就不是同一块了。映射成功后,和 Windows 一样要处理同步、生命周期和清理。进程崩溃不会自动 shm_unlink,名字会残留在系统里,下次启动要先判断是「上次残留」还是「另一个实例正在用」,通常配合锁文件或固定的实例管理策略。

另一条路是 mmap 一个普通文件。它不需要 shm_open,数据天然持久化,重启后还在;代价是要处理文件大小、落盘时机和磁盘 IO。临时共享用 shm_open,需要持久化用文件映射,这是常见的分工。

别把「零拷贝」理解成「没有成本」。映射本身要建立页表,第一次访问某页会触发缺页中断,从磁盘或分页文件读进来;两个进程同时访问同一页时,缓存一致性协议也要工作。共享内存省掉的是「数据在用户态和内核态之间复制」,省不掉页面调度。数据量小、访问次数少时,普通读写文件反而更简单,因为不用管映射大小、缺页和清理。

Unix socket:路径就是地址

如果只是传消息,Unix domain socket 往往比 TCP 更合适。它用文件系统路径作为地址,不经过网络协议栈,本机通信开销更低,还能利用文件权限控制谁能连接。Rust 标准库在 Unix 上提供 std::os::unix::net::UnixListener 和 UnixStream,接口和 TCP 很像:

let listener = UnixListener::bind("/tmp/app.sock")?;
for stream in listener.incoming() {
    let mut stream = stream?;
    stream.write_all(b"ok")?;
}

这段在 Windows 上无法编译,标注未实测。使用时要注意三件事。第一,socket 文件在进程退出后不会自动删除,下次 bind 会报「地址已占用」,启动时要先 remove_file,但要确认没有旧实例在跑。第二,SOCK_STREAM 和 TCP 一样没有消息边界,仍然要自己分帧;只有 SOCK_SEQPACKET 才保留消息边界,而标准库没有暴露这个类型。第三,路径长度有限制,通常一百字节左右,深层目录可能放不下;Linux 还有抽象命名空间(名字不以斜杠开头,不落文件系统),但那是 Linux 特有。

Windows 的对应物是命名管道。标准库同样不提供,要用 windows-sys 调 CreateNamedPipeW/ConnectNamedPipe,或者用封装库。命名管道支持「消息模式」和「字节模式」,消息模式下每次读写的边界是保留的;它还支持通过管道传递句柄,能力比 Unix socket 更复杂。这段本机没有实测,只说明它不是「没有方案」,而是「方案不在标准库里」。

还有一种高级能力是传递文件描述符:Unix 上通过 SCM_RIGHTS 把已打开的文件或 socket 从一个进程交给另一个进程,接收方拿到的不是路径,而是同一个打开实例。这在「父进程监听、子进程处理」的服务器模型里很有用。标准库不支持,需要 sendmsg/recvmsg,本机未实测。

生命周期、清理与安全

共享内存和 socket 都有「名字」这层资源,名字的生命周期和进程不一致。Windows 的命名映射对象在最后一个句柄关闭后消失,所以「父进程先退出、子进程还在用」时对象仍然活着;Unix 的 shm_open 对象要显式 shm_unlink,socket 文件要显式删除。崩溃、被 kill、机器重启,都会留下残留,启动逻辑必须能区分「残留」和「正在使用」。

安全边界也要提前想。共享内存的名字可猜,Unix socket 文件的权限决定谁能连,Windows 命名管道有安全描述符。默认配置往往比你以为的宽松。放在临时目录里的 socket 文件,如果目录权限是全局可写,别人可以删掉它再建一个假的,把客户端引到自己的服务上。这类攻击不需要破解任何加密,只需要文件权限配错。

还有一个实际问题是版本与布局。共享内存里的结构体布局依赖字段顺序、对齐、指针宽度,两个进程必须用完全一致的版本编译。升级时如果一边改了结构体,另一边还在用旧布局,读到的是错位的数据,而且不会报错。解决办法是加版本号、固定布局(用 #[repr(C)])、避免在共享内存里放指针和 String/Vec 这类带堆分配的类型。共享内存里只放 POD(普通数据)和偏移量,复杂结构放到别处。

现象对照

现象真实原因第一步查什么
子进程打开共享内存失败名字拼错、命名空间不同(Local 与 Global)、父进程已退出打印完整名字,确认创建与打开在同一会话
两个进程读到的值不一致映射不是 MAP_SHARED,或根本没映射同一对象检查映射标志与对象名,打印映射地址
读到写了一半的结构体共享内存没有同步,读写交错加跨进程锁/信号量,或改成单写多读
写入后另一个进程很久才看到编译器/CPU 重排,或缺少内存屏障用原子类型与明确的内存序,别只靠 volatile
程序退出后共享内存还在Unix 没有 shm_unlink,Windows 还有别的句柄没关检查所有 CloseHandle/munmap/shm_unlink 路径
重启后 socket 报「地址已占用」旧的 socket 文件残留,或旧进程还在先确认进程,再删除文件;不要盲目覆盖
大结构体在共享内存里读出乱码版本/布局不一致,或放了 String/Vec 这类堆指针固定 #[repr(C)] 布局,只放 POD 与偏移
同机其他用户能读到共享数据命名对象或 socket 文件权限过宽收紧 ACL/文件模式,敏感数据不要走共享内存

边界与代价

第一层是复杂度。共享内存把「两个进程看到同一份数据」做到了极致,但同步、生命周期、版本布局、崩溃恢复全部落在应用层。任何一项没处理好,排查难度都远高于「复制一份数据」。数据量不大时,socket 传一份副本反而更省心。

第二层是平台分裂。Windows 的文件映射、Unix 的 shm_open、各自的同步对象、各自的清理规则,几乎没有可移植的公共抽象。Rust 标准库选择不封装,意味着跨平台项目要么自己写一层薄封装,要么在文档里明确只支持某个平台。

第三层是安全。共享内存没有天然的访问控制,名字可被猜、权限可配错、内容可被同机进程篡改。它适合「同机、同信任域、高性能」的场景,不适合跨信任边界。需要隔离时,用 socket 加认证,或者把数据放在一个受控的服务里,让其他进程通过 API 访问。

第四层是可观测性。共享内存里的数据没有日志、没有版本、没有事务,出问题时只能靠 dump。要在关键位置记录「谁在什么时候写了哪块区域」,或者把共享内存当成缓存而不是唯一数据源,保证丢了也能重建。把共享内存当成「唯一真相」,是这类设计最常见的隐患。

小结

把这一篇收成四句:共享内存解决的是「同一块物理页」,不解决「谁先谁后」;Windows 用命名文件映射,Unix 用 shm_open 加 mmap,标准库都不封装;Unix socket 是传消息的本地通道,路径即地址,仍然要自己分帧;所有命名资源都要处理残留与清理,别假设进程会正常退出。

到这里,进程与线程这一层告一段落。最后一组问题是异步:async/await 看起来像多线程,实际上只是一套状态机语法,真正把它跑起来的是运行时。下一篇先不用 tokio,手写一个最小执行器,把 Future、Poll、Waker 这三样东西拆开看清楚。

当天可以自己验证的练习:

  1. 在本机用命名共享内存写一个父子进程计数器,确认父进程能看到子进程的修改;把名字里的 Local\ 去掉再试一次,观察行为是否一致。
  2. 把共享内存里的计数器改成两个进程同时加,去掉所有同步,跑一百万次,统计最终值是否小于预期。
  3. 在共享内存里放一个 #[repr(C)] 的结构体和一个 String,分别读写,说明为什么后者不能放。
  4. 在 Unix 环境(或 WSL)里用 UnixListener 写一个 echo 服务,确认 socket 文件在进程退出后仍然存在。
  5. 对一个普通文件做 mmap(用 memmap2 或 libc),两个进程一个写一个读,观察是否需要额外同步。

这些练习的重点不是 API,而是「谁负责同步、谁负责清理、出错时谁来恢复」。把这三个问题答清楚,才算真的会用共享内存。