Confundido cuando boost :: asio :: io_service ejecuta el método bloquea / desbloquea
Siendo un principiante total de Boost.Asio, estoy confundido conio_service::run()
. Agradecería que alguien me explicara cuando este método bloquea / desbloquea. Las documentaciones establecen:
losrun()
bloques de funciones hasta que todo el trabajo haya finalizado y no haya más manejadores que enviar, o hasta queio_service
Ha sido detenido.
Múltiples hilos pueden llamar alrun()
función para configurar un conjunto de hilos a partir de los cuales elio_service
Puede ejecutar manejadores. Todos los hilos que están esperando en la piscina son equivalentes y elio_service
Puede elegir cualquiera de ellos para invocar un controlador.
Una salida normal de larun()
función implica que laio_service
el objeto está paradostopped()
la función devuelve verdadero). Llamadas posteriores arun()
, run_one()
, poll()
opoll_one()
regresará inmediatamente a menos que haya una llamada previa areset()
.
¿Qué significa la siguiente declaración?
[...] no se necesitan más manejadores para ser enviados [...]
Al tratar de entender el comportamiento deio_service::run()
Me encontré con estoejemplo (ejemplo 3a). Dentro de ella, observo queio_service->run()
Bloquea y espera órdenes de trabajo.
// WorkerThread invines io_service->run()
void WorkerThread(boost::shared_ptr<boost::asio::io_service> io_service);
void CalculateFib(size_t);
boost::shared_ptr<boost::asio::io_service> io_service(
new boost::asio::io_service);
boost::shared_ptr<boost::asio::io_service::work> work(
new boost::asio::io_service::work(*io_service));
// ...
boost::thread_group worker_threads;
for(int x = 0; x < 2; ++x)
{
worker_threads.create_thread(boost::bind(&WorkerThread, io_service));
}
io_service->post( boost::bind(CalculateFib, 3));
io_service->post( boost::bind(CalculateFib, 4));
io_service->post( boost::bind(CalculateFib, 5));
work.reset();
worker_threads.join_all();
Sin embargo, en el siguiente código en el que estaba trabajando, el cliente se conecta mediante TCP / IP y los bloques del método de ejecución hasta que los datos se reciben de forma asíncrona.
typedef boost::asio::ip::tcp tcp;
boost::shared_ptr<boost::asio::io_service> io_service(
new boost::asio::io_service);
boost::shared_ptr<tcp::socket> socket(new tcp::socket(*io_service));
// Connect to 127.0.0.1:9100.
tcp::resolver resolver(*io_service);
tcp::resolver::query query("127.0.0.1",
boost::lexical_cast< std::string >(9100));
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
socket->connect(endpoint_iterator->endpoint());
// Just blocks here until a message is received.
socket->async_receive(boost::asio::buffer(buf_client, 3000), 0,
ClientReceiveEvent);
io_service->run();
// Write response.
boost::system::error_code ignored_error;
std::cout << "Sending message \n";
boost::asio::write(*socket, boost::asio::buffer("some data"), ignored_error);
Cualquier explicación derun()
que describe su comportamiento en los dos ejemplos siguientes sería apreciado.