在多线程程序中,io_service::notify_fork()在孩子中调用不安全.但是,Boost.Asio希望它可以基于 fork() support进行调用,因为这是当孩子关闭父母以前的内部文件描述符并创建新的内容时.虽然Boost.Asio显式列出了调用io_service :: notify_fork()的前提条件,保证在fork()期间内部组件的状态,但是对 implementation的简要概述则表明std :: vector :: push_back()可能会从免费商店分配内存,并且分配不能保证是异步信号安全的.

就这样说,一个可能值得考虑的解决方案是fork(),当它仍然是单线程时.子进程将保持单线程,并在父进程通过进程间通信被告知执行fork()和exec()时执行.这种分离通过在执行fork()和exec()时消除管理多个线程的状态的需要来简化问题.

以下是一个完整的示例,演示此方法,多线程服务器将通过UDP接收文件名,子进程将执行fork()和exec()来运行文件名/usr/bin/touch.为了使这个例子变得更加可读,我已经选择使用stackful coroutines.

#include <unistd.h> // execl,fork
#include <iostream>
#include <string>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/asio/spawn.hpp>
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
 
/// @brief launcher receives a command from inter-process communication,///        and will then fork,allowing the child process to return to
///        the caller.
class launcher
{
public:
  launcher(boost::asio::io_service& io_service,boost::asio::local::datagram_protocol::socket& socket,std::string& command)
    : io_service_(io_service),socket_(socket),command_(command)
  {}
 
  void operator()(boost::asio::yield_context yield)
  {
    std::vector<char> buffer;
    while (command_.empty())
    {
      // Wait for server to write data.
      std::cout << "launcher is waiting for data" << std::endl;
      socket_.async_receive(boost::asio::null_buffers(),yield);
 
      // Resize buffer and read all data.
      buffer.resize(socket_.available());
      socket_.receive(boost::asio::buffer(buffer));
 
      io_service_.notify_fork(boost::asio::io_service::fork_prepare);
      if (fork() == 0) // child
      {
        io_service_.notify_fork(boost::asio::io_service::fork_child);
        command_.assign(buffer.begin(),buffer.end());
      }
      else // parent
      {
        io_service_.notify_fork(boost::asio::io_service::fork_parent);
      }
    }
  }
 
private:
  boost::asio::io_service& io_service_;
  boost::asio::local::datagram_protocol::socket& socket_;
  std::string& command_;
};
 
using boost::asio::ip::udp;
 
/// @brief server reads filenames from UDP and then uses
///        inter-process communication to delegate forking and exec
///        to the child launcher process.
class server
{
public:
  server(boost::asio::io_service& io_service,short port)
    : io_service_(io_service),launcher_socket_(socket),socket_(boost::make_shared<udp::socket>(
        boost::ref(io_service),udp::endpoint(udp::v4(),port)))
  {}
 
  void operator()(boost::asio::yield_context yield)
  {
    udp::endpoint sender_endpoint;
    std::vector<char> buffer;
    for (;;)
    {
      std::cout << "server is waiting for data" << std::endl;
      // Wait for data to become available.
      socket_->async_receive_from(boost::asio::null_buffers(),sender_endpoint,yield);
 
      // Resize buffer and read all data.
      buffer.resize(socket_->available());
      socket_->receive_from(boost::asio::buffer(buffer),sender_endpoint);
      std::cout << "server got data: ";
      std::cout.write(&buffer[0],buffer.size());
      std::cout << std::endl;
 
      // Write filename to launcher.
      launcher_socket_.async_send(boost::asio::buffer(buffer),yield);
    }
  }
 
private:
  boost::asio::io_service& io_service_;
  boost::asio::local::datagram_protocol::socket& launcher_socket_;
 
  // To be used as a coroutine,server must be copyable,so make socket_
  // copyable.
  boost::shared_ptr<udp::socket> socket_;
};
 
int main(int argc,char* argv[])
{
  std::string filename;
 
  // Try/catch provides exception handling,but also allows for the lifetime
  // of the io_service and its IO objects to be controlled.
  try
  {
    if (argc != 2)
    {
      std::cerr << "Usage: <port>\n";
      return 1;
    }
 
    boost::thread_group threads;
    boost::asio::io_service io_service;
 
    // Create two connected sockets for inter-process communication.
    boost::asio::local::datagram_protocol::socket parent_socket(io_service);
    boost::asio::local::datagram_protocol::socket child_socket(io_service);
    boost::asio::local::connect_pair(parent_socket,child_socket);
 
    io_service.notify_fork(boost::asio::io_service::fork_prepare);
    if (fork() == 0) // child
    {
      io_service.notify_fork(boost::asio::io_service::fork_child);
      parent_socket.close();
      boost::asio::spawn(io_service,launcher(io_service,child_socket,filename));
    }
    else // parent
    {
      io_service.notify_fork(boost::asio::io_service::fork_parent);
      child_socket.close();
      boost::asio::spawn(io_service,server(io_service,parent_socket,std::atoi(argv[1])));
 
      // Spawn additional threads.
      for (std::size_t i = 0; i < 3; ++i)
      {
        threads.create_thread(
          boost::bind(&boost::asio::io_service::run,&io_service));
      }
    }
 
    io_service.run();
    threads.join_all();
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
  }
 
  // Now that the io_service and IO objects have been destroyed,all internal
  // Boost.Asio file descriptors have been closed,so the execl should be
  // in a clean state.  If the filename has been set,then exec touch.
  if (!filename.empty())
  {
    std::cout << "creating file: " << filename << std::endl;
    execl("/usr/bin/touch","touch",filename.c_str(),static_cast<char*>(0));
  }
}

1号航站楼：

$ls
a.out  example.cpp
$./a.out 12345
server is waiting for data
launcher is waiting for data
server got data: a
server is waiting for data
launcher is waiting for data
creating file: a
server got data: b
server is waiting for data
launcher is waiting for data
creating file: b
server got data: c
server is waiting for data
launcher is waiting for data
creating file: c
ctrl + c
$ls
a  a.out  b  c  example.cpp

2号航站楼：

$nc -u 127.0.0.1 12345
actrl + dbctrl + dcctrl + d