Boost、共享内存和向量

Question

我需要在进程之间共享一堆字符串（将来可能会更复杂的对象）。 我决定使用 boost::interprocess 但我无法让它工作。 我确信这是因为我不明白某些事情。 我遵循了他们的示例，但如果有使用该库经验的人可以查看我的代码并告诉我出了什么问题，我将非常感激。 问题是它似乎有效，但经过几次迭代后，我在读取器进程和有时在写入器进程上都遇到了各种异常。 这是我的实现的简化版本：

using namespace boost::interprocess;
class SharedMemoryWrapper
{
public:
    SharedMemoryWrapper(const std::string & name, bool server) :
      m_name(name),
      m_server(server)
    {
        if (server)
        {
            named_mutex::remove("named_mutex");
            shared_memory_object::remove(m_name.c_str());
            m_segment = new managed_shared_memory (create_only,name.c_str(),65536);         
            m_stackAllocator = new StringStackAllocator(m_segment->get_segment_manager());
            m_stack = m_segment->construct<StringStack>("MyStack")(*m_stackAllocator);
        }
        else
        {
            m_segment = new managed_shared_memory(open_only ,name.c_str());
            m_stack = m_segment->find<StringStack>("MyStack").first;
        }
        m_mutex = new named_mutex(open_or_create, "named_mutex");
    }

    ~SharedMemoryWrapper()
    {
        if (m_server)
        {
            named_mutex::remove("named_mutex");
            m_segment->destroy<StringStack>("MyStack");
            delete m_stackAllocator;
            shared_memory_object::remove(m_name.c_str());
        }
        delete m_mutex;
        delete m_segment;
    }

    void push(const std::string & in)
    {
        scoped_lock<named_mutex> lock(*m_mutex);
        boost::interprocess::string inStr(in.c_str());
        m_stack->push_back(inStr);
    }
    std::string pop()
    {
        scoped_lock<named_mutex> lock(*m_mutex);
        std::string result = "";
        if (m_stack->size() > 0)
        {
            result = std::string(m_stack->begin()->c_str());
            m_stack->erase(m_stack->begin());
        }
        return result;
    }
private:
    typedef boost::interprocess::allocator<boost::interprocess::string, boost::interprocess::managed_shared_memory::segment_manager> StringStackAllocator;
    typedef boost::interprocess::vector<boost::interprocess::string, StringStackAllocator> StringStack;
    bool m_server;
    std::string m_name;
    boost::interprocess::managed_shared_memory * m_segment;
    StringStackAllocator * m_stackAllocator;
    StringStack * m_stack;  
    boost::interprocess::named_mutex * m_mutex;
};

编辑编辑为使用named_mutex。 原始代码使用 interprocess_mutex 这是不正确的，但这不是问题。

EDIT2 我还应该注意到，事情在一定程度上是有效的。 写入器进程可以在读取器中断之前推送几个小字符串（或一个非常大的字符串）。 读者以 m_stack->begin() 行未引用有效字符串的方式中断。 这是垃圾。 然后进一步执行会抛出异常。

EDIT3 我已修改该类以使用 boost::interprocess::string 而不是 std::string。 读取器仍然因内存地址无效而失败。 这是读者/作者

//reader process
SharedMemoryWrapper mem("MyMemory", true);
std::string myString;
int x = 5;
do
{
    myString = mem.pop();
    if (myString != "") 
    {
        std::cout << myString << std::endl;
    }
} while (1); //while (myString != ""); 

//writer
SharedMemoryWrapper mem("MyMemory", false);
for (int i = 0; i < 1000000000; i++)
{
    std::stringstream ss;
    ss <<  i;  //causes failure after few thousand iterations
    //ss << "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" << i; //causes immediate failure
    mem.push(ss.str());
}
return 0;

Answer 1

关于您的实施，有几件事让我震惊。 一种是使用指向指定互斥对象的指针，而大多数 boost 库的文档往往不使用指针。 这导致我要求参考您在构建自己的测试用例时所使用的程序片段，因为我也遇到过类似的不幸事件，有时唯一的出路就是返回示例并一次向前迈出一步，直到我遇到了重大变化。

另一件似乎有问题的事情是您为共享内存分配了 65k 块，然后在测试代码中循环到 1000000000，每次迭代将字符串推入堆栈。

现代 PC 能够每微秒执行 1000 条指令甚至更多，而 Windows 等操作系统仍然在 15 毫秒内分配执行量子。 块，很快就会溢出该堆栈。 这是我对事情为何如此混乱的第一个猜测。

聚苯乙烯
我刚刚将我的名字修改为类似于我真实身份的东西。 然后讽刺的是，我对你问题的回答一直在浏览器页面的左上角盯着我们俩！ （当然，这是假设我是正确的，但在这个行业中情况往往并非如此。）

Answer 2

好吧，也许共享内存并不是解决您的问题的正确设计。 然而我们不知道，因为我们不知道您首先想要实现什么目标。