Question

我正在审核Boost网站上的HTTP Server 3示例。

你能解释为什么我需要strand每个连接？正如我所看到的，我们只在read-event的处理程序中调用read_some。因此基本上read_some调用是顺序的，因此不需要strand（并且item 2 of 3rd paragraph说同样的事情）。多线程环境中的风险在哪里？

Answer 1

文档是正确的。使用半双工协议实现，例如HTTP Server 3，strand不是必需的。调用链可以说明如下：

void connection::start()
{
  socket.async_receive_from(..., &handle_read);  ----.
}                                                    |
    .------------------------------------------------'
    |      .-----------------------------------------.
    V      V                                         |
void connection::handle_read(...)                    |
{                                                    |
  if (result)                                        |
    boost::asio::async_write(..., &handle_write); ---|--.
  else if (!result)                                  |  |
    boost::asio::async_write(..., &handle_write);  --|--|
  else                                               |  |
    socket_.async_read_some(..., &handle_read);  ----'  |
}                                                       |
    .---------------------------------------------------'
    |
    V
void handle_write(...)

如图所示，每个路径只启动一个异步事件。由于无法在socket_上同时执行处理程序或操作，因此它被认为是在隐式链中运行。

线程安全

虽然在示例中它并不是一个问题，但我想强调一下股线和组合操作的一个重要细节，例如boost::asio::async_write。在解释细节之前，让我们首先用Boost.Asio覆盖线程安全模型。对于大多数Boost.Asio对象，在对象上挂起多个异步操作是安全的。它只是指定对象的并发调用是不安全的。在下图中，每列代表一个线程，每一行代表一个线程在某个时刻正在做什么。

单个线程进行顺序调用是安全的，而其他线程没有：

 thread_1                             | thread_2
--------------------------------------+---------------------------------------
socket.async_receive(...);            | ...
socket.async_write_some(...);         | ...

多个线程可以安全地进行呼叫，但不能同时进行：

 thread_1                             | thread_2
--------------------------------------+---------------------------------------
socket.async_receive(...);            | ...
...                                   | socket.async_write_some(...);

但是，多个线程同时进行调用¹是不安全的：

 thread_1                             | thread_2
--------------------------------------+---------------------------------------
socket.async_receive(...);            | socket.async_write_some(...);
...                                   | ...

绞线

为防止并发调用，通常会从内部调用处理程序。这可以通过以下任一方式完成：

使用strand.wrap包装处理程序。这将返回一个新的处理程序，它将通过strand分派。
Posting或dispatching直接通过链。

组合操作是唯一的，因为在处理程序的链中调用 stream 的中间调用（如果存在），而不是组成的链操作已启动。与其他操作相比，这表明了指定链的位置的反转。下面是一些关注链使用的示例代码，它将演示通过非组合操作读取的套接字，并通过组合操作同时写入。

void start()
{
  // Start read and write chains.  If multiple threads have called run on
  // the service, then they may be running concurrently.  To protect the
  // socket, use the strand.
  strand_.post(&read);
  strand_.post(&write);
}

// read always needs to be posted through the strand because it invokes a
// non-composed operation on the socket.
void read()
{
  // async_receive is initiated from within the strand.  The handler does
  // not affect the strand in which async_receive is executed.
  socket_.async_receive(read_buffer_, &handle_read);
}

// This is not running within a strand, as read did not wrap it.
void handle_read()
{
  // Need to post read into the strand, otherwise the async_receive would
  // not be safe.
  strand_.post(&read);
}

// The entry into the write loop needs to be posted through a strand.
// All intermediate handlers and the next iteration of the asynchronous write
// loop will be running in a strand due to the handler being wrapped.
void write()
{
  // async_write will make one or more calls to socket_.async_write_some.
  // All intermediate handlers (calls after the first), are executed
  // within the handler's context (strand_).
  boost::asio::async_write(socket_, write_buffer_,
                           strand_.wrap(&handle_write));
}

// This will be invoked from within the strand, as it was a wrapped
// handler in write().
void handle_write()
{
  // handler_write() is invoked within a strand, so write() does not
  // have to dispatched through the strand.
  write();
}

处理程序类型的重要性

此外，在组合操作中，Boost.Asio使用argument dependent lookup（ADL）通过完成处理程序的链调用中间处理程序。因此，完成处理程序的类型具有适当的asio_handler_invoke()挂钩非常重要。如果类型擦除发生在没有相应asio_handler_invoke()挂钩的类型上，例如从boost::function的返回类型构造strand.wrap的情况，则中间处理程序将在外部执行的链，只有完成处理程序将在strand内执行。有关详细信息，请参阅this答案。

在以下代码中，所有中间处理程序和完成处理程序将在strand中执行：

boost::asio::async_write(stream, buffer, strand.wrap(&handle_write));

在以下代码中，只有完成处理程序将在strand中执行。没有任何中间处理程序将在链中执行：

boost::function<void()> handler(strand.wrap(&handle_write));
boost::asio::async_write(stream, buffer, handler);

<子> 1。 revision history记录了此规则的异常情况。如果操作系统支持，同步读取，写入，接受和连接操作都是线程安全的。为了完整起见，我将其包含在此处，但建议谨慎使用。

Answer 2

我认为这是因为合成操作async_write。 async_write由多个socket::async_write_some异步组成。 Strand有助于序列化这些操作。 asio的作者Chris Kohlhoff在1:17左右的boostcon talk中简要地谈到了这一点。

使用boost :: asio时，为什么每个连接需要strand？

2 个答案:

线程安全

绞线

处理程序类型的重要性