Cuando leo el código fuente de asio, tengo curiosidad acerca de cómo asio hace que los datos estén sincronizados entre los hilos, incluso se hizo un hilo implícito. Estos son los codigos en asio:

io_service :: run

 mutex::scoped_lock lock(mutex_);

  std::size_t n = 0;
  for (; do_run_one(lock, this_thread, ec); lock.lock())
    if (n != (std::numeric_limits<std::size_t>::max)())
      ++n;
  return n;

io_service :: do_run_one

 while (!stopped_)
  {
    if (!op_queue_.empty())
    {
      // Prepare to execute first handler from queue.
      operation* o = op_queue_.front();
      op_queue_.pop();
      bool more_handlers = (!op_queue_.empty());

      if (o == &task_operation_)
      {
        task_interrupted_ = more_handlers;

        if (more_handlers && !one_thread_)
        {
          if (!wake_one_idle_thread_and_unlock(lock))
            lock.unlock();
        }
        else
          lock.unlock();

        task_cleanup on_exit = { this, &lock, &this_thread };
        (void)on_exit;

        // Run the task. May throw an exception. Only block if the operation
        // queue is empty and we're not polling, otherwise we want to return
        // as soon as possible.
        task_->run(!more_handlers, this_thread.private_op_queue);
      }
      else
      {
        std::size_t task_result = o->task_result_;

        if (more_handlers && !one_thread_)
          wake_one_thread_and_unlock(lock);
        else
          lock.unlock();

        // Ensure the count of outstanding work is decremented on block exit.
        work_cleanup on_exit = { this, &lock, &this_thread };
        (void)on_exit;

        // Complete the operation. May throw an exception. Deletes the object.
        o->complete(*this, ec, task_result);

        return 1;
      }
    }

en su do_run_one, el desbloqueo de mutex se realiza antes de ejecutar el controlador. Si hay una cadena implícita, el controlador no se ejecutará al mismo tiempo, pero el problema es: el hilo A ejecuta un controlador que modifica los datos y el hilo B ejecuta el siguiente controlador que lee los datos que fueron modificados por el hilo A. Sin la protección de mutex , ¿cómo se ve el hilo B los cambios de datos realizados por el hilo A? El desbloqueo mutex antes de la ejecución del controlador no hace que ocurra una relación antes de que los hilos accedan a los datos a los que accedió el controlador. Cuando voy más allá, la ejecución del controlador usa una cosa llamada fenced_block:

 completion_handler* h(static_cast<completion_handler*>(base));
    ptr p = { boost::addressof(h->handler_), h, h };

    BOOST_ASIO_HANDLER_COMPLETION((h));

    // Make a copy of the handler so that the memory can be deallocated before
    // the upcall is made. Even if we're not about to make an upcall, a
    // sub-object of the handler may be the true owner of the memory associated
    // with the handler. Consequently, a local copy of the handler is required
    // to ensure that any owning sub-object remains valid until after we have
    // deallocated the memory here.
    Handler handler(BOOST_ASIO_MOVE_CAST(Handler)(h->handler_));
    p.h = boost::addressof(handler);
    p.reset();

    // Make the upcall if required.
    if (owner)
    {
      fenced_block b(fenced_block::half);
      BOOST_ASIO_HANDLER_INVOCATION_BEGIN(());
      boost_asio_handler_invoke_helpers::invoke(handler, handler);
      BOOST_ASIO_HANDLER_INVOCATION_END;
    }

¿Que es esto? Sé que valla parece una primitiva de sincronización que es compatible con C ++ 11, pero esta valla está totalmente escrita por la propia asio. ¿Este fenced_block ayuda a hacer el trabajo de sincronización de datos?

ACTUALIZADO

Después de google y leoesta yesta, de hecho, use el primitivo de valla de memoria para sincronizar los datos en subprocesos, que es más rápido que el desbloqueo hasta que el controlador se ejecuta completo (diferencia de velocidad en x86). De hecho, la palabra clave volátil de Java se implementa insertando la barrera de la memoria después de escribir y antes de leer esta variable para que la relación suceda antes.

Si alguien pudiera describir simplemente la implementación de la valla de memoria de Asio o agregar algo que no haya comprendido o entendido mal, lo aceptaré.