fork时如何实现MmapHandler析构函数仅在父进程调用一次

fork创建子进程时会完整复制父进程的地址空间，父进程中创建的MmapHandler对象会在子进程中生成一个字节完全一致的副本，子进程退出时会触发该副本的析构函数调用munmap。

注：POSIX标准规定munmap仅会解除调用进程自身地址空间的内存映射，不会直接影响其他进程的共享内存访问。但如果子进程在业务逻辑执行中途因为异常、栈展开等原因触发MmapHandler析构，会导致子进程自身后续访问共享内存触发段错误，同时不符合RAII资源所有权的设计原则。

你提到的PID判断方案完全可以做到无侵入，不需要手动传入PID，所有逻辑封装在类内部即可，是工程上最简洁优雅的实现：

• 构造函数中自动调用getpid()记录创建映射的进程ID作为所有者ID
• 析构时仅当当前进程ID等于所有者ID时，才执行munmap操作
• 禁用拷贝构造、拷贝赋值，避免同进程内多个实例重复释放映射；支持移动语义，符合现代C++ RAII设计规范

修正后的MmapHandler实现 #

// MmapHandler.h
#include <sys/mman.h>
#include <unistd.h>
#include <stdexcept>
#include <utility>

template<typename T>
class MmapHandler{
protected:
  size_t m_size = 0;
  T* m_ptr = MAP_FAILED;
  pid_t m_owner_pid = -1; // 内部记录创建映射的所有者进程ID，无需用户传入

  // 释放当前持有的映射（仅所有者进程可执行）
  void cleanup() noexcept {
    if(m_ptr != MAP_FAILED && getpid() == m_owner_pid){
      munmap(static_cast<void*>(m_ptr), m_size);
      m_ptr = MAP_FAILED;
      m_size = 0;
      m_owner_pid = -1;
    }
  }
public:
  explicit MmapHandler(size_t size) : m_size(size) {
    // 修正原代码中mmap调用缺失的右括号
    m_ptr = static_cast<T*>(mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0));
    if(m_ptr == MAP_FAILED){
      throw std::runtime_error("mmap failed");
    }
    m_owner_pid = getpid(); // 构造时自动记录所有者PID，无需要用户手动传参
  }

  // 禁用拷贝语义，避免同进程内多实例重复释放
  MmapHandler(const MmapHandler&) = delete;
  MmapHandler& operator=(const MmapHandler&) = delete;

  // 支持移动语义，允许同进程内转移映射所有权
  MmapHandler(MmapHandler&& other) noexcept {
    *this = std::move(other);
  }
  MmapHandler& operator=(MmapHandler&& other) noexcept {
    if(this != &other){
      cleanup(); // 先释放自身持有的资源
      // 接管源对象的资源
      m_ptr = other.m_ptr;
      m_size = other.m_size;
      m_owner_pid = other.m_owner_pid;
      // 清空源对象的资源标记，避免源对象析构时重复释放
      other.m_ptr = MAP_FAILED;
      other.m_size = 0;
      other.m_owner_pid = -1;
    }
    return *this;
  }

  ~MmapHandler() {
    cleanup();
  }

  // 常规访问接口
  T* get() const noexcept { return m_ptr; }
  T& operator*() const noexcept { return *m_ptr; }
  T* operator->() const noexcept { return m_ptr; }

  // 主动放弃所有权，析构时不再执行munmap
  T* release() noexcept {
    T* ret = m_ptr;
    m_ptr = MAP_FAILED;
    m_size = 0;
    m_owner_pid = -1;
    return ret;
  }
};

业务代码无需修改 #

原有main.cpp的逻辑不需要做任何调整，类内部会自动处理多进程下的析构逻辑：

// main.cpp
#include <sys/wait.h>
#include <cstdio>
// 引入上述MmapHandler头文件即可

int num_procs = 3;
pid_t pids[3];
MmapHandler<char> sharedMemory(4096); // 父进程构造时自动记录自身为所有者

int main() {
  for(int i=0; i<num_procs; i++)
  {
    if((pids[i] = fork()) < 0){
      perror("fork");
    }
    else if (pids[i] == 0){
      // 子进程可直接使用sharedMemory，析构时PID不匹配，不会执行munmap
      // 业务逻辑
      // ...
      return 0;
    }
  }

  while(wait(NULL) > 0);
  // 所有子进程退出后，父进程执行析构，仅调用一次munmap完成资源回收
  return 0;
}

• 仅为子进程删除析构函数的方案完全不可行：fork是内核层面的内存复制，不会触发C++的构造/析构/拷贝函数，无法在编译期区分父、子进程的对象实例。
• 无所有权包装类方案可行但易用性差：可以实现一个只持有映射指针、析构不执行munmap的MmapView类，fork后子进程主动调用sharedMemory.release()放弃所有权，再用MmapView接管指针访问，但该方案需要业务层手动处理，容易遗漏出错，远不如类内部自动判断的方案简洁。
• pthread_atfork方案实现冗余：可以通过注册fork回调，在子进程创建后自动遍历所有MmapHandler实例清空所有权标记，不需要依赖PID判断，但需要额外维护全局实例链表，实现复杂度更高，最终效果和PID判断方案完全一致，工程上没有必要。

补充说明：不存在完全不依赖POSIX接口的"纯C原生"方案，因为C标准本身没有定义进程、fork相关的抽象，所有多进程逻辑都需要依赖操作系统API，我们只需要把OS相关逻辑封装在类内部，对外提供符合C++ RAII规范的无感知接口即可。

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