附加进程时提升删除 managed_shared_memory

Question

我有 2 个进程，进程 1 创建一个 boost managed_shared_memory 段，进程 2 打开这个段。然后进程1重新启动，进程1的启动有以下内容，

struct vshm_remove
{
    vshm_remove() 
    { 
        boost::interprocess::shared_memory_object::remove("VMySharedMemory"); 
    }
    ~vshm_remove()
    {
        boost::interprocess::shared_memory_object::remove("VMySharedMemory"); 
    }
} vremover;

我了解当进程 1 启动或结束时，将在我的共享内存上调用 remove 方法，但它不应该只在进程 2 未附加到它的情况下将其删除吗？我正在使用以下方法附加到进程 2 中的共享内存，

boost::interprocess::managed_shared_memory *vfsegment;
vfsegment = new boost::interprocess::managed_shared_memory(boost::interprocess::open_only, "VMySharedMemory");

我注意到无论进程 2 是否连接，共享内存都会被删除。

Answer 1

我认为文档中没有提到如果附加进程，shared_memory_object::remove 将失败。

请参阅此部分以供参考：Removing shared memory。特别是：

如果共享内存对象不存在或者它被另一个进程打开，这个函数可能失败。

这意味着无论如何调用shared_memory_object::remove("foo") 将尝试删除名为“foo”的共享内存。

该函数 (source here) 的实现反映了该行为：

inline bool shared_memory_object::remove(const char *filename)
{
   try{
      //Make sure a temporary path is created for shared memory
      std::string shmfile;
      ipcdetail::tmp_filename(filename, shmfile);
      return ipcdetail::delete_file(shmfile.c_str());
   }
   catch(...){
      return false;
   }
}

根据我发布生产代码的经验，我已经成功不调用shared_memory_object::remove，直到我不再需要访问共享内存。

我编写了一个非常简单的示例主程序，您可能会发现它对您有所帮助。它将根据您的运行方式附加到、创建或删除共享内存。编译后尝试以下步骤：

1. 使用 c 运行以创建共享内存（默认为 1.0K）并插入虚拟数据
2. 使用 o 运行以打开（“附加到”）共享内存并读取虚拟数据（默认情况下每 10 秒循环读取一次）
3. 在单独的会话中，使用 r 运行以删除共享内存
4. 使用 o 再次运行以尝试打开。请注意，这将（几乎可以肯定）失败，因为在上一步中（再次，几乎可以肯定）删除了共享内存
5. 随意从第二步终止进程

为什么上面的第2步在调用shared_memory_object::remove后仍然可以访问数据，请看Constructing Managed Shared Memory。具体来说：

当我们打开一个托管共享内存时

• 打开了一个共享内存对象。
• 整个共享内存对象映射到进程的地址空间。

很可能，因为共享内存对象被映射到进程的地址空间，所以不再直接需要共享内存文件本身。

我意识到这是一个相当人为的例子，但我认为更具体的例子可能会有所帮助。

#include <cctype>   // tolower()
#include <iostream>
#include <string>
#include <unistd.h> // sleep()
#include <boost/interprocess/shared_memory_object.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>

int main(int argc, char *argv[])
{
  using std::cerr; using std::cout; using std::endl;
  using namespace boost::interprocess;

  if (argc == 1) {
    cout << "usage: " << argv[0] << " <command>\n  'c'   create\n  'r'   remove\n  'a'   attach" << endl;
    return 0;
  }

  const char * shm_name = "shared_memory_segment";
  const char * data_name = "the_answer_to_everything";

  switch (tolower(argv[1][0])) {
    case 'c':
        if (shared_memory_object::remove(shm_name)) { cout << "removed: " << shm_name << endl; }
        managed_shared_memory(create_only, shm_name, 1024).construct<int>(data_name)(42);
        cout << "created: " << shm_name << "\nadded int \"" << data_name << "\": " << 42 << endl;
        break;
    case 'r':
      cout << (shared_memory_object::remove(shm_name) ? "removed: " : "failed to remove: " ) << shm_name << endl;
      break;
    case 'a':
      {
        managed_shared_memory segment(open_only, shm_name);
        while (true) { 
          std::pair<int *, std::size_t> data = segment.find<int>( data_name );
          if (!data.first || data.second == 0) {
            cerr << "Allocation " << data_name << " either not found or empty" << endl;
            break;
          }
          cout << "opened: " << shm_name << " (" << segment.get_segment_manager()->get_size()
               << " bytes)\nretrieved int \"" << data_name << "\": " << *data.first << endl;
          sleep(10);
        }
      }
      break;
    default:
      cerr << "unknown command" << endl;
      break;
  }
  return 0;
}

Answer 2

另外一件有趣的事情 - 再添加一个案例：

case 'w':
  {
    managed_shared_memory segment(open_only, shm_name);
      std::pair<int *, std::size_t> data = segment.find<int>( data_name );
      if (!data.first || data.second == 0) {
        cerr << "Allocation " << data_name << " either not found or empty" << endl;
        break;
      }
      *data.first = 17;
      cout << "opened: " << shm_name << " (" << segment.get_segment_manager()->get_size()
           << " bytes)\nretrieved int \"" << data_name << "\": " << *data.first << endl;
  }
  break;

附加选项“w”导致附加内存并改为写入“17”（“最随机的随机数”）。有了它，您可以执行以下操作：

控制台 1：执行“c”，然后执行“a”。报告使用值 42 创建的内存。

控制台 2：执行“w”。在 Console1 上，您会看到数字已更改。

控制台 2：执行“r”。内存移除成功，Console 1 仍然打印 17。

控制台 2：执行“c”。它将报告已创建的内存值为 42。

控制台 2：执行“a”。你会看到 42，控制台 1 仍然打印 17。

这证实了——只要它在所有平台上都以相同的方式工作，但 boost 声明它确实如此——你可以使用这种方式将内存块从一个进程发送到另一个进程，而“生产者”只需要确认“消费者”附加了该块，以便“生产者”现在可以将其删除。消费者也不必在附加下一个块之前分离前一个块。