BOOST c++库学习 之 interprocess入门实战指南 以及使用interprocess库实现简单进程间通讯功能的服务端、客户端测试 （共享内存）

Boost.Interprocess 库简介

Boost.Interprocess 专门用于实现进程间通信（IPC）和共享内存管理。该库为开发者提供了多种机制，使多个进程能够高效地共享数据、同步操作，并通过共享内存、消息队列和命名管道等方式进行通信。它适用于需要进程间协作的应用程序，尤其是在高性能计算和资源受限的环境中。

特点

1. 高效的进程间通信：

   • 提供多种 IPC 机制，包括共享内存、消息队列和命名管道，适应不同的通信需求，保证数据快速传递和处理。

2. 共享内存支持：

   • 支持创建和管理共享内存段，允许不同进程共享同一块内存空间，从而显著提高数据共享的效率和减少内存使用。

3. 丰富的同步机制：

   • 提供跨进程的同步工具，如互斥量、条件变量和信号量，确保在多进程环境下资源的安全访问，避免数据竞争和死锁。

4. 跨平台兼容：

   • Boost.Interprocess 是跨平台的，支持在多种操作系统上运行（如 Windows、Linux 和 macOS），使得开发者可以编写具有高可移植性的应用程序。

5. 与标准 C++ 集成：

   • 提供与标准 C++ 类似的接口，使开发者能够快速上手，并且可以与标准 C++ 库无缝集成。

主要组件

1. 共享内存管理

   • shared_memory_object: 创建和管理共享内存对象，允许多个进程访问同一个内存段。
   • mapped_region: 将共享内存或内存映射文件映射到进程的地址空间，以便进程访问共享数据。
   • allocator: 用于在共享内存中分配和管理内存，与托管内存段（如 managed_shared_memory）结合使用。

2. 托管内存段

   • managed_shared_memory: 提供托管的共享内存段，允许在共享内存中分配、查找和销毁对象。
   • managed_mapped_file: 类似于 managed_shared_memory，但基于内存映射文件，实现数据的持久化共享。
   • offset_ptr: 用于管理和操作共享内存中的指针，以确保跨进程的内存访问正确。

3. 进程间通信机制

   • message_queue: 实现进程间的消息队列，支持同步或异步的消息传递，适用于生产者-消费者模型。
   • named_pipe: 提供基于命名管道的流式数据通信。

4. 同步机制

   • interprocess_mutex: 跨进程的互斥量，确保对共享资源的安全访问。
   • interprocess_semaphore: 提供信号量机制，控制对共享资源的访问。
   • interprocess_condition: 条件变量，用于进程之间的同步操作。
   • named_mutex: 基于名称的互斥量，支持跨进程的资源同步。

5. 文件锁

   • file_lock: 锁定文件，防止多个进程同时对文件进行读写操作，确保文件访问的原子性和一致性。

应用场景

1. 多进程数据共享：当多个进程需要访问同一块数据时，使用共享内存可以显著提高效率，特别是在处理大数据集时，如图像处理、科学计算等领域。

2. 生产者-消费者模型：Boost.Interprocess 的消息队列机制非常适合实现生产者-消费者模式，多个生产者进程可以通过消息队列将任务发送给消费者进程进行处理。

3. 多进程服务器架构： 在需要处理多个并发连接的服务器应用中，可以使用共享内存和同步机制来管理连接状态和请求处理，提升系统的并发性能。

4. 资源受限环境中的进程同步：在嵌入式系统或其他资源受限的环境中，Boost.Interprocess 的同步机制可以确保资源的高效利用，并避免死锁和数据竞争。

5. 数据持久化共享：使用内存映射文件，可以将数据持久化到磁盘，并在不同进程间共享数据，适用于需要持久存储和快速访问的大型数据集。

Boost.Interprocess 接口API介绍

1. 共享内存管理接口

这些接口允许创建、管理和访问共享内存。

• shared_memory_object:

  • 功能: 用于创建、打开和管理共享内存对象。
  • 关键函数:
    • shared_memory_object(open_or_create_t, const char *name, mode_t mode): 打开或创建共享内存对象。
    • truncate(offset_t size): 设置共享内存的大小。
    • remove(const char *name): 删除共享内存对象。

• mapped_region:

  • 功能: 将共享内存对象映射到进程的地址空间中，便于访问共享内存中的数据。
  • 关键函数:
    • mapped_region(const shared_memory_object &shm, mode_t mode): 构造一个映射区域。
    • get_address(): 获取映射区域的起始地址。
    • get_size(): 获取映射区域的大小。

• allocator:

  • 功能: 提供分配器，用于在共享内存中分配对象。通常与托管内存段一起使用。
  • 关键函数:
    • allocate(size_type n): 分配内存块。
    • deallocate(pointer p, size_type n): 释放内存块。

2. 托管内存段接口

这些接口允许在共享内存中管理 C++ 对象。

• managed_shared_memory:

  • 功能: 提供托管的共享内存段，允许在共享内存中分配、查找和销毁对象。
  • 关键函数:
    • construct<T>(const char *name): 在共享内存中构造对象。
    • find<T>(const char *name): 查找共享内存中的对象。
    • destroy<T>(const char *name): 销毁共享内存中的对象。

• managed_mapped_file:

  • 功能: 类似于 managed_shared_memory，但用于内存映射文件。允许在文件中管理 C++ 对象，支持数据持久化。
  • 关键函数: 与 managed_shared_memory 类似。

• offset_ptr:

  • 功能: 用于在托管内存段中实现指针的封装，以便在不同进程中正确访问对象。
  • 关键函数:
    • offset_ptr(): 构造函数。
    • operator->(): 获取指向对象的指针。

3. 进程间通信接口

这些接口允许进程之间进行数据交换。

• message_queue:

  • 功能: 用于进程间的消息传递，支持同步和异步通信。
  • 关键函数:
    • send(const void *buffer, size_type buffer_size, unsigned int priority): 发送消息。
    • receive(void *buffer, size_type buffer_size, size_type &received_size, unsigned int &priority): 接收消息。
    • remove(const char *name): 删除消息队列。

• named_pipe:

  • 功能: 提供基于命名管道的通信机制，适用于进程间的双向流式数据传输。
  • 关键函数:
    • write(const void *buffer, std::size_t size): 向管道写数据。
    • read(void *buffer, std::size_t size): 从管道读数据。

4. 同步机制接口

这些接口确保多进程环境中对共享资源的安全访问。

• interprocess_mutex:

  • 功能: 跨进程的互斥量，用于同步对共享资源的访问。
  • 关键函数:
    • lock(): 加锁。
    • unlock(): 解锁。
    • try_lock(): 尝试加锁。

• interprocess_recursive_mutex:

  • 功能: 支持递归锁定的跨进程互斥量，允许同一线程多次获取锁。
  • 关键函数: 与 interprocess_mutex 类似。

• interprocess_semaphore:

  • 功能: 用于控制多个进程对共享资源的访问。
  • 关键函数:
    • wait(): 等待信号量。
    • post(): 增加信号量。

• interprocess_condition:

  • 功能: 条件变量，用于在线程或进程之间的同步操作。
  • 关键函数:
    • wait(interprocess_mutex &mut): 等待条件变量。
    • notify_one(): 唤醒一个等待线程。
    • notify_all(): 唤醒所有等待线程。

5. 文件锁接口

这些接口用于控制对文件的访问，以防止多个进程同时修改文件。

• file_lock:

  • 功能: 锁定文件，防止其他进程同时访问文件。
  • 关键函数:
    • lock(): 锁定文件。
    • try_lock(): 尝试锁定文件。
    • unlock(): 解锁文件。

• named_mutex:

  • 功能: 基于名称的互斥量，支持不同进程之间的同步。
  • 关键函数:
    • lock(): 加锁。
    • unlock(): 解锁。

6. 其他实用工具

这些工具帮助管理共享内存中的复杂数据结构。

• interprocess_allocator:

  • 功能: 提供跨进程的分配器，通常用于在共享内存中分配 STL 容器。
  • 关键函数: 与标准分配器接口类似。

• interprocess_containers:

  • 功能: 提供 STL 兼容的容器，如 interprocess_vector、interprocess_string，这些容器可以使用 interprocess_allocator 在共享内存中进行分配。

使用boost.message_queue消息队列以及共享内存实现的进程间通讯的简单例程

生产者代码

#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/sync/interprocess_mutex.hpp>
#include <boost/interprocess/sync/interprocess_condition.hpp>
#include <boost/interprocess/ipc/message_queue.hpp>
#include <iostream>
#include <cstring>

struct SharedData {
    boost::interprocess::interprocess_mutex mutex;
    boost::interprocess::interprocess_condition condition;
    bool data_ready;
    char message[100];
};

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

    // 创建或打开共享内存
    managed_shared_memory shared_memory(open_or_create, "SharedMemory", 1024);

    // 在共享内存中创建一个 SharedData 对象
    SharedData* shared_data = shared_memory.find_or_construct<SharedData>("SharedData")();
    shared_data->data_ready = false;

    // 创建消息队列
    message_queue::remove("MessageQueue");  // 删除现有的消息队列
    message_queue mq(create_only, "MessageQueue", 1, sizeof(bool));

    {
        // 锁定共享内存中的互斥量
        scoped_lock<interprocess_mutex> lock(shared_data->mutex);

        // 写入消息到共享内存
        std::string message = "Hello from Producer!";
        std::strncpy(shared_data->message, message.c_str(), sizeof(shared_data->message));

        // 标记数据准备好了
        shared_data->data_ready = true;

        // 通知消费者数据已经准备好
        shared_data->condition.notify_one();
    }

    // 发送消息到消息队列通知消费者
    bool notify = true;
    mq.send(&notify, sizeof(notify), 0);

    std::cout << "Producer sent: " << shared_data->message << std::endl;

    return 0;
}

消费者代码

#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/sync/interprocess_mutex.hpp>
#include <boost/interprocess/sync/interprocess_condition.hpp>
#include <boost/interprocess/ipc/message_queue.hpp>
#include <iostream>
#include <cstring>

struct SharedData {
    boost::interprocess::interprocess_mutex mutex;
    boost::interprocess::interprocess_condition condition;
    bool data_ready;
    char message[100];
};

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

    // 打开共享内存
    managed_shared_memory shared_memory(open_only, "SharedMemory");

    // 查找共享内存中的 SharedData 对象
    SharedData* shared_data = shared_memory.find<SharedData>("SharedData").first;

    if (!shared_data) {
        std::cerr << "Error: Could not find SharedData in shared memory!" << std::endl;
        return 1;
    }

    // 打开消息队列
    message_queue mq(open_only, "MessageQueue");

    // 等待消息队列中的通知
    bool notify;
    message_queue::size_type recvd_size;
    unsigned int priority;
    mq.receive(&notify, sizeof(notify), recvd_size, priority);

    {
        // 锁定共享内存中的互斥量
        scoped_lock<interprocess_mutex> lock(shared_data->mutex);

        // 等待数据准备好
        while (!shared_data->data_ready) {
            shared_data->condition.wait(lock);
        }

        std::cout << "Consumer received: " << shared_data->message << std::endl;
    }

    return 0;
}

编译和运行

1. 将代码分别保存为 producer.cpp 和 consumer.cpp。
2. 编译代码：

   g++ producer.cpp -o producer -lrt -lpthread
   g++ consumer.cpp -o consumer -lrt -lpthread
   

3. 先运行 producer，然后运行 consumer：

   ./producer
   ./consumer
   

输出结果

假设一切正常，输出结果应如下所示：

• 生产者输出:

  Producer sent: Hello from Producer!
  

• 消费者输出:

  Consumer received: Hello from Producer!
  

代码解析

• 共享内存:

  • 生产者通过 managed_shared_memory 创建或打开一个共享内存段 SharedMemory。
  • 在共享内存中，生产者创建了一个 SharedData 结构体，其中包含了消息、互斥量和条件变量。
  • 消费者打开相同的共享内存段，并查找 SharedData 对象。

• 互斥量和条件变量:

  • 生产者使用互斥量锁定共享内存区域，写入消息，并标记数据已准备好。然后通知消费者数据已经准备好。
  • 消费者在接收到消息队列中的通知后，锁定互斥量，等待数据准备好，然后读取消息。

• 消息队列:

  • 生产者使用消息队列发送一个布尔值通知消费者数据已经准备好。
  • 消费者从消息队列中接收通知，确认可以开始读取共享内存中的数据。