Boost.Interprocess 开源 C++ 进程间通信库深度解析

从共享内存、内存映射文件到跨进程同步原语与消息队列的完整指南

---

1. 背景

1.1 进程隔离与协作的矛盾

操作系统为每个进程提供独立的虚拟地址空间。进程 A 中 0x1000 地址上的数据，在进程 B 的 0x1000 地址上可能是完全无关的内容。这种隔离是稳定性的基石------一个进程崩溃不会直接踩坏另一个进程的内存。但现实业务又天然需要进程间协作：

• 多个工作进程共享一份配置/缓存/计数值；
• 主进程与子进程传递大块数据（图像、日志、批处理结果）；
• 一组服务进程互斥访问同一资源（打印、写同一文件、抢占同一设备）；
• 生产者进程源源不断产出任务，消费者进程并行消费。

于是"进程间通信（IPC，Inter-Process Communication）"成为系统编程的永恒主题。

1.2 IPC 方式全景对比

方式	数据形态	是否需要内核搬运	典型吞吐量级	典型延迟	跨主机	典型场景
匿名管道 / 命名管道	字节流	是	MB/s ~ 百MB/s	数十 µs	否	父子进程、命令行流水线
System V / POSIX 消息队列	结构化消息	是	MB/s 级	数十 µs	否	简单任务分发
共享内存	任意内存	仅在映射时	GB/s 级	数百 ns ~ µs	否	高频大数据交换
内存映射文件	文件内容	仅缺页时	GB/s 级（命中页缓存）	µs 级	否	大文件随机访问、数据库缓冲
Socket / TCP	字节流/报文	是	百MB/s ~ GB/s	µs ~ ms	是	网络通信、分布式
信号量 / 文件锁	计数/锁	是	高频但不传数据	µs 级	否（文件锁可跨机器）	进程互斥

为什么共享内存是最快的 IPC？ 其他 IPC 每次传输都要经历"用户态 → 内核态 → 内核缓冲区 → 内核态 → 用户态"的拷贝链路；共享内存则是在两个进程的地址空间各建立一段映射，指向同一物理内存页，一方写入、另一方立即可见，全程没有内核参与数据搬运，也不存在序列化/反序列化开销。配合无锁或轻量锁，可以达到 GB/s 级吞吐，比管道高 1~2 个数量级。

1.3 为什么选 Boost.Interprocess

C++ 标准库至今（C++23）没有提供任何跨进程通信设施------std::thread/std::mutex 只能在线程间同步，无法跨进程。原生方案有：

• POSIX：shm_open + mmap + sem_open + mq_open；
• Windows：CreateFileMapping + MapViewOfFile + CreateMutex/CreateSemaphore + CreateFileMapping 消息队列（实际用命名管道/邮槽更多）。

问题在于：两套 API 完全不同，且裸 API 只提供字节级视图------要在共享内存里放一个 std::vector<std::string> 这种 C++ 对象几乎不可能（涉及指针、分配器、构造/析构）。

Boost.Interprocess 的价值：

1. 跨平台统一：一套 API 同时覆盖 POSIX 与 Windows，内部自动选择 mmap/CreateFileMapping 等底层实现；
2. C++ 对象友好：提供 offset_ptr（偏移指针）、managed_shared_memory（托管内存段）、interprocess_allocator 与配套容器，把 C++ 对象直接"种"进共享内存；
3. 同步原语齐全：命名互斥量、信号量、条件变量、读写锁、文件锁，全部支持跨进程；
4. 消息队列：开箱即用的跨进程消息队列，支持阻塞/非阻塞/超时收发；
5. 头文件即用：Boost 头文件库，多数组件无需编译链接（boost::interprocess 核心为 header-only，消息队列等依赖平台库时会自动链接）。

1.4 适用场景速览

场景	推荐设施
高频共享计数器/状态标志	shared_memory_object + mapped_region + 原子/互斥量
复杂对象跨进程共享（配置树、索引、缓存）	managed_shared_memory + offset_ptr + interprocess 容器
大文件随机访问、多进程共享同一文件内容	file_mapping + mapped_region
跨进程互斥/临界区	named_mutex / interprocess_mutex（放共享内存）
进程计数限流	named_semaphore
跨进程条件等待（数据就绪通知）	named_condition / interprocess_condition
简单任务/消息分发	message_queue
多进程写同一文件协调	file_lock

---

2. 核心 API 说明

2.1 共享内存对象与内存映射

shared_memory_object：代表一个具名的共享内存对象（内核对象）。

#include <boost/interprocess/shared_memory_object.hpp>

namespace bip = boost::interprocess;

// 创建（已存在则抛 interprocess_exception）
bip::shared_memory_object shm(
    bip::create_only,          // 打开方式
    "MySharedMemory",          // 对象名（跨进程一致的字符串）
    bip::read_write);          // 访问模式 read_only / read_write

// 打开（不存在则抛异常）
bip::shared_memory_object shm(
    bip::open_only, "MySharedMemory", bip::read_write);

// 打开或创建（推荐用于两端角色模糊的场景）
bip::shared_memory_object shm(
    bip::open_or_create, "MySharedMemory", bip::read_write);

// 设置大小（字节）。新创建的对象大小为 0，必须 truncate！
shm.truncate(4096);

// 查询大小
bip::offset_t size = shm.get_size();

// 删除（静态成员，按名字删除，所有映射关闭后真正销毁）
bip::shared_memory_object::remove("MySharedMemory");

mapped_region：把共享内存对象（或文件）映射进当前进程地址空间。

bip::mapped_region region(shm, bip::read_write);
void* addr = region.get_address();   // 映射基址（每次进程不同！）
std::size_t size = region.get_size(); // 映射大小

注意 ：get_address() 返回的基址在不同进程中通常不同，这就是后面 offset_ptr 存在的根本原因。

2.2 offset_ptr：解决跨进程指针问题

普通指针保存的是"绝对地址"。进程 A 映射共享内存在 0x7f...a000，进程 B 映射在 0x7f...b000，进程 A 写入的裸指针值在进程 B 中指向错误位置------轻则读错数据，重则段错误。

offset_ptr<T> 保存的是目标相对于指针自身的偏移量 （ptrdiff_t），解引用时用"自身地址 + 偏移"计算目标地址。由于共享内存在每个进程内都是连续映射的，同一对象内部任意两点的偏移在任意进程中完全一致，因此偏移指针天然跨进程有效。

#include <boost/interprocess/offset_ptr.hpp>

bip::offset_ptr<int> p;              // 类似 int*
p = static_cast<int*>(region.get_address());
int v = *p;                          // 透明解引用
p->someMethod();                     // 调用成员
p++;                                 // 指针运算（偏移指针也支持）

offset_ptr 支持裸指针的绝大多数语义：解引用、箭头、比较、加减、bool 判断、get() 取回裸指针。它的大小是 sizeof(ptrdiff_t)（8 字节），替换裸指针后对象即可安全放入共享内存。

2.3 managed_shared_memory：托管内存段

裸 shared_memory_object + 手写放置新表达式太原始。managed_shared_memory 在共享内存之上内置了一个段管理器（segment manager），提供命名对象构造、查找、销毁，以及段内内存分配：

#include <boost/interprocess/managed_shared_memory.hpp>

bip::managed_shared_memory segment(
    bip::open_or_create, "MyManagedShm", 65536); // 名字 + 初始大小（字节）

// 构造命名对象（返回指针）
int* i = segment.construct<int>("MyInt")(42);          // 相当于 new int(42)

// 查找（不存在返回空 pair）
std::pair<int*, std::size_t> res = segment.find<int>("MyInt");
if (res.second) { /* 找到，res.first 为指针 */ }

// 查找或构造
int* j = segment.find_or_construct<int>("MyInt")(0);

// 销毁
segment.destroy<int>("MyInt");

// 匿名构造（不命名，随段生命周期，不可 find）
int* k = segment.construct<int>(bip::anonymous_instance)();

段管理器还提供 get_segment_manager()、get_size()、get_free_memory()、check_sanity()、grow()（扩容）等能力。

2.4 interprocess 分配器与容器

普通 std::vector<int> 使用 std::allocator，内存从进程堆分配------放进共享内存的 vector 内部指针全指向进程私有堆，另一个进程一访问就崩。Boost.Interprocess 提供段内分配器与容器：

#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/containers/vector.hpp>
#include <boost/interprocess/containers/string.hpp>
#include <boost/interprocess/containers/map.hpp>

// 段内分配器
typedef bip::allocator<int, bip::managed_shared_memory::segment_manager>
    IntAlloc;
typedef bip::vector<int, IntAlloc> ShmVector;

// 在段内构造容器
ShmVector* v = segment.construct<ShmVector>("MyVector")(
    segment.get_segment_manager());   // 必须传入段管理器！

// 使用与 std::vector 几乎一致
v->push_back(1);
v->push_back(2);

支持的容器包括 vector、deque、list、slist、set、map、multiset、multimap、string、wstring、basic_string、flat_map 等，全部要求构造时传入段管理器。

2.5 跨进程同步原语

命名同步原语（按名字跨进程访问，内核级对象）：

API	说明
named_mutex	跨进程互斥量。lock()/unlock()/try_lock()/timed_lock()
named_semaphore	跨进程计数信号量。wait()/post()/try_wait()/timed_wait()
named_condition	跨进程条件变量，需配合 scoped_lock<named_mutex>
named_sharable_mutex	跨进程读写锁。lock_sharable()/lock()/unlock_sharable()/unlock()
file_lock	文件锁，基于文件字节范围，可跨主机（NFS）

匿名同步原语（对象本身放入共享内存，随段共享）：

API	说明
interprocess_mutex	可放入共享内存的互斥量
interprocess_semaphore	可放入共享内存的信号量
interprocess_condition	可放入共享内存的条件变量
interprocess_sharable_mutex	可放入共享内存的读写锁
interprocess_recursive_mutex	可放入共享内存的递归互斥量

使用 scoped_lock 做 RAII 加锁：

#include <boost/interprocess/sync/named_mutex.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>

bip::named_mutex mutex(bip::open_or_create, "MyMutex");
{
    bip::scoped_lock<bip::named_mutex> lock(mutex);  // 构造加锁
    // ... 临界区 ...
}   // 析构解锁

// 程序退出前清理（可选，但推荐）
bip::named_mutex::remove("MyMutex");

2.6 message_queue：跨进程消息队列

#include <boost/interprocess/ipc/message_queue.hpp>

// 创建：名字、最大消息数、单条消息最大字节数
bip::message_queue mq(
    bip::create_only, "MyQueue", 100, sizeof(int));

// 发送（阻塞）；try_send（非阻塞）；timed_send（带超时）
int data = 42;
mq.send(&data, sizeof(data), 0);        // 第三参数是优先级 0~100

// 接收（阻塞）
unsigned priority;
std::size_t recvd_size;
mq.receive(&data, sizeof(data), recvd_size, priority);

// 非阻塞/超时接收
if (mq.try_receive(&data, sizeof(data), recvd_size, priority)) { /* ok */ }
if (mq.timed_receive(&data, sizeof(data), recvd_size, priority,
                     boost::posix_time::microsec_clock::universal_time()
                     + boost::posix_time::seconds(1))) { /* ok */ }

// 查询
std::size_t max_msg, cur_msg;
mq.get_max_msg(&max_msg);
mq.get_num_msg(&cur_msg);

bip::message_queue::remove("MyQueue");

2.7 file_mapping：内存映射文件

把磁盘文件映射进地址空间，读写即读写文件（经页缓存），适合大文件随机访问、多进程共享同一文件视图：

#include <boost/interprocess/file_mapping.hpp>

bip::file_mapping fm("data.bin", bip::read_only);
bip::mapped_region region(fm, bip::read_only,
                          0, 4096);      // (offset, size)
const char* bytes = static_cast<const char*>(region.get_address());

注意：offset 必须是系统页大小（通常 4096）的整数倍，否则抛出异常。

---

3. 详细使用说明（可编译示例）

3.1 示例一：共享内存计数器（两个进程读写共享 int）

writer.cpp

#include <boost/interprocess/shared_memory_object.hpp>
#include <boost/interprocess/mapped_region.hpp>
#include <cstring>
#include <iostream>

int main() {
    using namespace boost::interprocess;

    // 清理历史残留，避免 create_only 失败
    shared_memory_object::remove("CounterShm");
    shared_memory_object shm(create_only, "CounterShm", read_write);
    shm.truncate(sizeof(int));               // 关键：设置大小

    mapped_region region(shm, read_write);
    int* counter = static_cast<int*>(region.get_address());
    *counter = 0;

    std::cout << "Writer: counter initialized at "
              << counter << std::endl;

    // 等 reader 读完（简化：sleep 演示）
    while (*counter < 100) {
        // reader 在改，这里只读展示
    }
    return 0;
}

reader.cpp

#include <boost/interprocess/shared_memory_object.hpp>
#include <boost/interprocess/mapped_region.hpp>
#include <iostream>

int main() {
    using namespace boost::interprocess;
    shared_memory_object shm(open_only, "CounterShm", read_write);
    mapped_region region(shm, read_write);
    int* counter = static_cast<int*>(region.get_address());

    for (int i = 1; i <= 100; ++i) {
        *counter = i;                        // 直接写共享内存
        std::cout << "Reader: counter = " << *counter << std::endl;
    }
    return 0;
}

要点：示例未加锁，仅演示映射读写。实际多进程并发读写同一共享变量必须配互斥量或原子操作（见 3.4）。

3.2 示例二：managed_shared_memory 构造复杂对象

#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/offset_ptr.hpp>
#include <iostream>

struct Node {
    bip::offset_ptr<Node> next;   // 用偏移指针替代裸指针！
    int value;
    explicit Node(int v) : value(v) {}
};

int main() {
    using namespace boost::interprocess;

    managed_shared_memory segment(open_or_create, "NodeShm", 65536);

    Node* head = segment.find_or_construct<Node>("Head")(0);
    Node* n1 = segment.construct<Node>(anonymous_instance)(1);
    Node* n2 = segment.construct<Node>(anonymous_instance)(2);

    head->next = n1;              // 偏移指针赋值
    n1->next = n2;
    n2->next = nullptr;

    // 遍历链表（在另一个进程中同样有效）
    for (Node* p = head; p; p = p->next.get()) {
        std::cout << p->value << " ";
    }
    std::cout << std::endl;

    segment.destroy<Node>("Head");
    shared_memory_object::remove("NodeShm");
    return 0;
}

说明：Node 里的 next 若写成裸 Node*，进程 B 打开同一段后解引用必然崩溃；offset_ptr 则完全安全。

3.3 示例三：共享内存中的 vector

#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/containers/vector.hpp>
#include <boost/interprocess/containers/string.hpp>
#include <iostream>

int main() {
    using namespace boost::interprocess;

    typedef allocator<char, managed_shared_memory::segment_manager>
        CharAlloc;
    typedef basic_string<char, std::char_traits<char>, CharAlloc>
        ShmString;
    typedef allocator<ShmString, managed_shared_memory::segment_manager>
        StrAlloc;
    typedef vector<ShmString, StrAlloc> ShmStringVector;

    managed_shared_memory segment(open_or_create, "StrShm", 1 << 20);

    ShmStringVector* v =
        segment.find_or_construct<ShmStringVector>("StrVec")(
            segment.get_segment_manager());   // 传入段管理器！

    v->push_back(ShmString("hello", segment.get_segment_manager()));
    v->push_back(ShmString("boost", segment.get_segment_manager()));
    v->push_back(ShmString("interprocess", segment.get_segment_manager()));

    for (const auto& s : *v) std::cout << s << std::endl;

    segment.destroy<ShmStringVector>("StrVec");
    shared_memory_object::remove("StrShm");
    return 0;
}

关键 ：容器与字符串都必须使用段内分配器，且每次构造元素时传入段管理器，否则内部缓冲会分配到进程堆，跨进程即崩。

3.4 示例四：named_mutex 保护共享数据

// 两个进程共用的临界区保护
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/sync/named_mutex.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>
#include <iostream>

int main() {
    using namespace boost::interprocess;

    managed_shared_memory segment(open_or_create, "MtxShm", 4096);
    named_mutex mutex(open_or_create, "SharedMutex");

    int* count = segment.find_or_construct<int>("Count")(0);

    for (int i = 0; i < 100000; ++i) {
        scoped_lock<named_mutex> lock(mutex);   // 跨进程互斥
        ++(*count);                              // 安全自增
    }
    std::cout << "count = " << *count << std::endl;
    return 0;
}

同时启动两个该程序实例，最终 count 必为 200000------若去掉锁，几乎必然小于 200000（丢失更新）。

3.5 示例五：message_queue 生产者-消费者

producer.cpp

#include <boost/interprocess/ipc/message_queue.hpp>
#include <iostream>

int main() {
    using namespace boost::interprocess;
    message_queue::remove("TaskQueue");
    message_queue mq(create_only, "TaskQueue", 1024, sizeof(int));

    for (int i = 0; i < 100; ++i) {
        mq.send(&i, sizeof(i), 0);      // 队列满时阻塞
    }
    std::cout << "Produced 100 tasks" << std::endl;
    return 0;
}

consumer.cpp

#include <boost/interprocess/ipc/message_queue.hpp>
#include <iostream>

int main() {
    using namespace boost::interprocess;
    message_queue mq(open_only, "TaskQueue");

    int task;
    std::size_t recvd;
    unsigned priority;
    while (true) {
        mq.receive(&task, sizeof(task), recvd, priority); // 队列空时阻塞
        std::cout << "Got task " << task << std::endl;
        if (task == 99) break;
    }
    message_queue::remove("TaskQueue");
    return 0;
}

注意：receive 的缓冲区大小必须 ≥ 创建队列时声明的 max_msg_size，否则抛 message_queue_error。

3.6 示例六：内存映射大文件

#include <boost/interprocess/file_mapping.hpp>
#include <boost/interprocess/mapped_region.hpp>
#include <fstream>
#include <iostream>

int main() {
    using namespace boost::interprocess;

    // 准备 1MB 测试文件
    std::ofstream ofs("big.bin", std::ios::binary);
    for (int i = 0; i < 1024 * 1024; ++i) ofs.put(static_cast<char>(i));
    ofs.close();

    file_mapping fm("big.bin", read_only);
    mapped_region region(fm, read_only);   // 整个文件映射

    const char* data = static_cast<const char*>(region.get_address());
    std::cout << "mapped size = " << region.get_size() << std::endl;
    std::cout << "byte[1000] = " << static_cast<int>(data[1000])
              << std::endl;
    return 0;
}

要点：文件映射省去 seek+read 的系统调用，页缓存命中时随机访问接近内存速度；多个进程映射同一文件可共享同一份页缓存，实现零拷贝文件协作。

---

4. 常错点 / 坑（18 条高发问题）

4.1 把裸指针/引用放进共享内存

struct Bad { int* p; };   // ❌ p 保存绝对地址

不同进程映射基址不同，进程 B 解引用进程 A 写入的裸指针 → 段错误。 修法：一律用 offset_ptr<T> 或指向段内地址的指针（经 segment.get_address_from_handle / get_handle_from_address 转换）。

4.2 容器使用默认分配器

segment.construct<std::vector<int>>("V")();   // ❌ 内部用 std::allocator

vector 的堆缓冲在进程私有堆上，另一进程访问即崩。 修法：typedef allocator<int, segment_manager> A; vector<int, A>，构造时传 segment.get_segment_manager()。

4.3 忘记 truncate

shared_memory_object 创建后大小默认为 0，不 truncate 就映射，映射大小是 0，读写直接越界崩溃。 修法：创建后立即 shm.truncate(size)。

4.4 create_only 重复创建抛异常

进程 A 已创建 create_only 的共享内存/队列/互斥量，进程 B 再用 create_only 打开同一名字 → interprocess_exception。 修法：两端角色对等时用 open_or_create；仅一端创建时，另一端用 open_only。

4.5 共享内存残留导致"创建失败"

进程异常退出（未调用 remove）后，Linux 下 /dev/shm 或 Windows 下内核对象残留。下次启动用 create_only 会抛"已存在"。 修法：启动时先 remove 再 create_only（只允许单一生命周期时），或始终用 open_or_create 并做初始化检测。

4.6 进程崩溃导致命名互斥量/信号量永久锁死

进程 A 持有 named_mutex 时崩溃，锁不会被自动释放（内核对象不感知"持有者死亡"），进程 B 将永久阻塞。 修法：加锁加超时 timed_lock（失败则上报/清理）；或改用 file_lock（某些平台关闭句柄即释放）；或用 named_mutex + 心跳/看门狗识别僵死持有者。

4.7 命名冲突

不同程序用了同一个共享内存名/互斥量名（如都叫 "data"），互相干扰，行为诡异难排查。 修法：命名统一加项目前缀，如 "/myapp/cache_v1"；Windows 注意 Global\ 与 Local\ 会话隔离。

4.8 匿名对象无法 find，误用命名查找

construct<T>(anonymous_instance) 创建的对象没有名字 ，find<T>("Name") 永远找不到。 修法：需要跨进程查找的对象必须命名构造；匿名对象只用于本段内指针可达的场景。

4.9 映射基址不同导致的内存比较/哈希

对共享内存内地址做绝对地址比较（如 p1 < p2）、把裸地址写进日志或哈希表，在不同进程中结果不一致。 修法：用 offset_ptr 的比较运算符（基于偏移，跨进程一致）；日志记录用偏移 ptr - base。

4.10 file_mapping 的 offset 未页对齐

mapped_region(fm, mode, offset, size) 的 offset 不是页大小（通常 4096）整数倍 → 抛异常。 修法：offset 向下取整到页边界，再通过 get_address() + 余数 访问。

4.11 message_queue 接收缓冲区过小

创建队列时声明单条消息 max_msg_size 为 N，接收方缓冲区小于 N → receive 抛 message_queue_error。 修法：接收缓冲区 ≥ 创建时声明的 max_msg_size；可用 get_max_msg_size() 查询。

4.12 队列满/空时阻塞误判为死锁

send 在队列满时阻塞、receive 在队列空时阻塞。生产者消费者数量不匹配时表现为"卡死"。 修法：需要非阻塞语义时用 try_send/try_receive；需要超时用 timed_send/timed_receive（注意传 boost::posix_time 绝对时间点）。

4.13 共享内存大小与对齐

某些平台要求共享内存对象大小是页大小的整数倍或至少为某最小值；truncate(1) 在个别平台可能失败或映射大小被向上取整。 修法：统一按页大小（4096）对齐分配；用 mapped_region::get_size() 确认实际大小。

4.14 权限/ACL 问题

共享内存/命名对象默认权限可能只允许创建用户访问。多用户进程协作时另一用户 open_only 失败（Permission denied）。 修法：构造时传入 permissions(0666)；Windows 可配置 DACL；或统一用同一用户运行相关进程。

4.15 跨架构（32/64 位）共享同一块内存

32 位与 64 位进程的 offset_t、offset_ptr 大小、对齐与结构体布局不同，直接共享结构体会错位。 修法：生产环境保证所有参与者同架构；需要异构时使用固定宽度整数 + 显式序列化布局，避免直接共享 C++ 对象。

4.16 remove 与映射生命周期的时序

shared_memory_object::remove(name) 只是标记删除：所有已存在的映射仍可继续访问 ，直到最后一个映射关闭才真正销毁。若 A 进程 remove 后立即重建同名对象，B 进程可能仍在访问旧对象。 修法：遵守"先停参与者 → 再 remove → 再重建"的生命周期协议。

4.17 与线程同步混用

在共享内存中放置 std::mutex（而非 interprocess_mutex）→ 进程 B 无法使用它（std::mutex 是进程内对象）；反过来，在单进程多线程场景滥用 named_mutex 则性能远低于线程互斥量。 修法：跨进程 → named_* 或 interprocess_*；仅线程间 → std::mutex/std::shared_mutex。

4.18 忘记 RAII / 异常路径泄漏

手写 lock() 后 unlock() 忘写或异常跳出，锁泄漏。同理 segment.construct 后忘 destroy，段内内存泄漏。 修法：加锁一律用 scoped_lock；命名对象在生命周期结束时 destroy；进程退出前统一清理命名对象。

---

5. 性能与选型总结

5.1 性能参考（x86-64 Linux，同机双进程）

方式	单向吞吐（1KB 消息）	往返延迟
共享内存 + 自旋/互斥	数 GB/s	~1 µs 量级
Boost message_queue	百MB/s 级	~10 µs 量级
Unix 域 Socket（SOCK_STREAM）	数百MB/s	~10 µs 量级
TCP loopback	数百MB/s	~30 µs 量级

（数据为典型量级，随系统与负载波动；共享内存在大数据块场景优势更明显。）

5.3 选型决策树

需要跨进程传数据？
├─ 数据量小、频率低（事件/任务/命令）
│   └─ message_queue（简单可靠）或 ZeroMQ（跨主机）
├─ 数据量大、频率高（图像/日志/缓存/计数值）
│   ├─ 结构化 C++ 对象 → managed_shared_memory + interprocess 容器
│   └─ 原始字节 → shared_memory_object + mapped_region
├─ 大文件共享/随机访问
│   └─ file_mapping + mapped_region
└─ 仅需跨进程互斥/限流（不传数据）
    └─ named_mutex / named_semaphore / file_lock

5.4 总结

• Boost.Interprocess 是 C++ 生态中跨进程通信的事实标准库：一套 API 覆盖共享内存、内存映射文件、进程同步原语与消息队列，跨 POSIX/Windows；
• 核心心法：共享内存内一律用 offset_ptr 与段内分配器，容器必须用 interprocess 版本，同步必须用 named_* 或 interprocess_* 原语；
• 性能优势：共享内存零内核拷贝，是本地多进程高频数据交换的最优解；配合消息队列/互斥量做控制面，可构建高性能多进程架构；
• 风险点：生命周期管理（remove/残留）、崩溃恢复（锁泄漏）、命名规范、跨架构布局是生产环境最容易踩坑的地方，建议封装统一的 RAII 管理类（如段生命周期守卫 + 命名统一前缀）。

---

6. FAQ 速查表

问题	答案
共享内存里能放 std::string 吗？	不能放标准分配器的版本；用 bip::basic_string（段内分配器）
offset_ptr 和裸指针哪个快？	解引用多一次加法，开销可忽略；安全优先
进程崩溃后命名互斥量会解锁吗？	不会自动解锁，需 timed_lock + 看门狗策略
Windows 上共享内存名有讲究吗？	有长度限制；跨会话用 Global\ 前缀
共享内存数据需要加锁吗？	需要，除非使用原子操作且满足无锁条件
两个进程能用 std::mutex 互斥吗？	不能，std::mutex 仅线程内；跨进程用 named_mutex
create_only 与 open_or_create 怎么选？	单一生命周期用前者（配合启动清理）；长期服务用后者
message_queue 是线程安全的吗？	是，可多线程并发收发同一队列
共享内存段能扩容吗？	managed_shared_memory::grow() 可尝试扩容，但进程 A 已映射后需重新映射
需要跨主机通信，能用本库吗？	不能，跨主机请用 socket/ZeroMQ/gRPC
Boost.Interprocess 需要编译吗？	核心为 header-only；Windows 下部分组件自动链接系统库
共享内存对象删除后已映射区域还能用吗？	能，现有映射继续有效直到关闭（引用计数语义）