Correct usage of asio::io_service::strand?

Question

Here is my code:

void client_connection::serve()
{
    asio::async_read(this->socket_, asio::buffer(&buffer_, buffer_.size()),

        // predicate/condition (do I wrap this?)
        std::bind(&client_connection::handle_read_predicate, this->shared_from_this(), std::placeholders::_1, std::placeholders::_2),

        // handler
        this->strand_.wrap(std::bind(&client_connection::handle_read, this->shared_from_this(), std::placeholders::_1, std::placeholders::_2)));
}

std::size_t client_connection::handle_read_predicate(const asio::error_code& error, std::size_t bytes_)
{
    // useless flawed function, for now

    // std::cout << "test: reached predicate, " << bytes_ << std::endl;

    return 0;
}

void client_connection::handle_read(const asio::error_code& error_, std::size_t bytes_)
{
    // useless flawed function, for now

    if (error_) return;

    this->serve();
}

My question is whether it would be correct usage of asio::io_service::strand to wrap the predicate/condition handler with the same strand_ object; if so, why, and if not, please explain.

Answer 1

There is no need to wrap it in the strand.

Per the strand documented, for composed operations, such as the async_read free function, all intermediate handlers are invoked within the handler's strand. A side-effect of this is that all intermediate invocations of the CompletionCondition are also invoked from within the strand.

However, make sure to dispatch the initial invocation of client_connection::serve() within a strand when starting the asynchronous loop, as the initial CompletionCondition and asynchronous read socket operation occur within the context of the caller. For example, in the following illustration, all calls to socket.async_read(), client_connection::handle_read_predicate(), and client_connection::handle_read() will occur within the strand:

void client_connection::start()
{
  strand_.dispatch(std::bind(&client_connection::serve,
                             shared_from_this())) --------.
}                                                         |
    .-----------------------------------------------------'
    |  .--------------------------------------------------.
    V  V                                                  |
void client_connection::serve()                           |
{                                                         |
  async_read(socket_, buffer,                             |
    std::bind(&client_connection::handle_read_predicate,  |
              this),                                      |
    strand_.wrap(                                         |
      std::bind(&client_connection::handle_read,          |
                shared_from_this())); --.                 |
}                                       |                 |
    .-----------------------------------'                 |
    V                                                     |
void client_connection::handle_read(...)                  |
{                                                         |
  if (error) return;                                      |
  serve();  ----------------------------------------------'
}