boost::interprocess共享内存字符串重复运行段错误排查

你的问题核心在于共享内存中使用了非共享内存感知的容器和未绑定正确分配器的字符串，导致跨进程访问时内存地址失效，具体来说有几个关键错误：

1. 用std::vector而非Boost共享内存版bip::vector #

std::vector内部使用绝对虚拟地址管理元素，当共享内存被映射到新进程时，这些地址在新进程的地址空间中是无效的（不同进程的虚拟地址空间完全隔离）。而bip::vector专门为共享内存设计，它使用偏移量代替绝对指针，确保在任何进程中都能正确定位元素。

你的代码里注释掉了bip::vector改用std::vector，这是再次运行时访问元素出错的根本原因之一。

2. Message中的bip::string未绑定共享内存分配器 #

bip::string默认使用标准堆分配器，而非共享内存分配器。当你给超过SSO长度的字符串赋值时，bip::string会尝试在进程私有堆上分配内存——但共享内存中的对象成员不能指向私有堆，否则其他进程（或再次运行的当前进程）访问时会触发段错误。小字符串因为SSO存储在bip::string的内部缓冲区，不需要访问外部内存，所以不会出问题。

3. 共享内存大小计算错误 #

你手动计算的共享内存大小严重不足：bip::vector和bip::string需要额外内存存储内部结构和实际字符串数据，手动计算对象大小的方式完全无法覆盖这些需求，容易导致内存溢出或分配失败。

4. find_or_construct的误用 #

当再次运行程序时，find_or_construct会找到之前创建的MyCustomData实例，但此时std::vector的内部状态（比如元素指针）是旧进程的虚拟地址，在新进程中完全无效，直接访问元素必然出错。

修正后的代码 #

下面是修复了所有问题的完整代码，关键修改点已标注：

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

namespace bip = boost::interprocess;

struct BadSharedMemoryAccess final : public std::exception {
    BadSharedMemoryAccess(std::string&& msg): msg_{std::move(msg)} {}
    virtual const char* what() const noexcept {
        return msg_.c_str();
    }
private:
    std::string msg_;
};

// 修改1：让Message接受分配器模板参数，确保内部的bip::string使用共享内存分配器
template <typename Alloc>
struct Message {
    using String = bip::string<typename Alloc::segment_manager>;
    String message_;

    // 显式构造函数，传递分配器给内部的bip::string
    explicit Message(const Alloc& alloc) : message_(alloc) {}
};

template<typename Alloc>
class MyCustomData final {
public:
    using MessageType = Message<Alloc>;
    // 修改2：使用bip::vector代替std::vector，确保跨进程兼容
    using VectorType = bip::vector<MessageType, Alloc>;

    MyCustomData(std::size_t number_of_messages, Alloc alloc = {})
        : init_add_index_{0}, init_handle_index_{-1}, messages_(alloc) {
        // 修改3：提前预留空间，避免动态分配时的内存问题
        messages_.reserve(number_of_messages);
        // 用正确的分配器构造每个Message
        for (std::size_t i = 0; i < number_of_messages; ++i) {
            messages_.emplace_back(alloc);
        }
    }

public:
    uint_fast64_t init_add_index_;
    int_fast64_t init_handle_index_;
    VectorType messages_;
};

template<typename DataType, typename DataAllocator>
class SharedMemory {
public:
    template<typename... Args>
    SharedMemory(std::string const& shm_segment_name, std::size_t const segment_size, std::string const& shm_object_name, Args&&... args)
        : shm_object_name_{shm_object_name} {
        std::cout << "Attempting to access shared memory segment: " << shm_segment_name << ", requested size: " << segment_size << std::endl;

        try {
            // 先尝试打开已有的共享内存
            shm_ = bip::managed_shared_memory{bip::open_only, shm_segment_name.c_str()};
            std::cout << "Opened existing shared memory segment." << std::endl;
        } catch (const bip::interprocess_exception&) {
            // 如果不存在，创建新的
            std::cout << "Creating new shared memory segment." << std::endl;
            // 修改4：不需要手动计算页大小，Boost会自动处理
            shm_ = bip::managed_shared_memory{bip::create_only, shm_segment_name.c_str(), segment_size};
        }

        DataAllocator const allocInstance{shm_.get_segment_manager()};
        // 修改5：使用find_or_construct时，确保只有首次创建时才初始化参数
        data_ = shm_.find_or_construct<DataType>(shm_object_name.c_str())(std::forward<Args>(args)..., allocInstance);

        if (data_)
            std::cout << "Successfully accessed shared memory object." << std::endl;
        else
            throw BadSharedMemoryAccess{"Failed to find or construct shared memory object: " + shm_object_name_};
    }

    virtual ~SharedMemory() {
        std::cout << "Closing shared memory segment." << std::endl;
        // 注意：不要在这里销毁共享内存，除非你确定不再需要它
        // bip::shared_memory_object::remove(shm_segment_name_.c_str());
    }

    DataType& getData() {
        if (!data_)
            throw BadSharedMemoryAccess{"Cannot access shared memory object: " + shm_object_name_};
        return *data_;
    }

protected:
    DataType* data_;
private:
    std::string const shm_object_name_;
    bip::managed_shared_memory shm_;
};

namespace sharable {
    using SegmentManager = bip::managed_shared_memory::segment_manager;
    using DataAllocator = bip::allocator<Message<SegmentManager>, SegmentManager>;
    template<typename Alloc>
    using DataType = MyCustomData<Alloc>;
}

int main() {
    const std::size_t max_number_of_elements = 1000000;
    // 修改6：增大共享内存大小，确保能容纳所有元素和字符串数据
    const std::size_t shm_size = 1024 * 1024 * 512; // 512MB，根据实际需求调整

    try {
        auto shmem_data = std::make_shared<SharedMemory<MyCustomData<sharable::DataAllocator>, sharable::DataAllocator>>(
            "SHM_SEGMENT",
            shmem_size,
            "SHM_CONTAINER",
            max_number_of_elements);

        auto& data = shmem_data->getData();
        auto& shmem_vec = data.messages_;

        std::cout << "Vector size: " << shmem_vec.size() << std::endl;

        for (std::size_t i = 0; i < max_number_of_elements; ++i) {
            std::string s{"blablabla11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" + std::to_string(i)};
            // 修改7：直接赋值，bip::string会用共享内存分配器处理大字符串
            shmem_vec[i].message_ = s;
        }

        std::cout << "Successfully wrote all messages to shared memory." << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}

关键修改说明 #

1. Message模板化：让Message接受分配器参数，确保内部的bip::string使用共享内存的段管理器分配内存，避免私有堆分配。
2. 替换std::vector为bip::vector：bip::vector使用偏移量管理元素，跨进程访问时地址有效。
3. 正确初始化容器：在MyCustomData构造函数中，用共享内存分配器构造每个Message实例，确保所有成员都关联到共享内存。
4. 改进共享内存访问逻辑：先尝试打开已有共享内存，不存在再创建，避免重复初始化。
5. 合理设置共享内存大小：手动计算大小不可靠，直接设置足够大的固定值（或根据实际需求动态调整）。

内容的提问来源于stack exchange，提问作者bladzio