boost :: pool de threads asio io_service

Quelle est la bonne utilisation des paramètres d'un pool de threads pour io_service? Ces 2 états de la la documentation sont en me jetant off:

io_service::run

Une sortie normale à partir de la fonction run() implique que le io_service objet est à l'arrêt (à l'arrêt() la fonction renvoie la valeur true). Les appels suivants à run(), run_one(), poll() ou poll_one() retourne immédiatement, sauf s'il existe un précédent appel à reset().

io_service::reset

Cette fonction doit être appelée avant toute seconde ou plus tard, d'invocations de l'run(), run_one(), poll() ou poll_one() fonctions lors d'un appel précédent de ces fonctions retournés en raison de la io_service d'être arrêté ou en cours d'exécution hors du travail.

Voici ce que je suis en train de faire:

boost::thread_group     m_Threads;
boost::asio::io_service m_IoService;
boost::barrier          m_Barrier(numThreads);

for( unsigned int i = 0; i < numThreads; ++i )
{
    m_Threads.create_thread(
        [&]()
        {
            for(;;)
            {
                m_IoService.run();

                if( m_Barrier.wait() )  // will only return true for 1 thread
                {
                    m_IoService.reset();
                }
                m_Barrier.wait();
            }
        });
}

m_IoService.stop();
m_Threads.interrupt_all();
m_Threads.join_all();

Tout semble fonctionner correctement si je viens de mettre m_IoService.run() dans une boucle infinie (dont la documentation semble indiquer devrait pas être le cas). Quelle est la corriger?

source d'informationauteur David

  1. 17

    run() est un appel bloquant, et exécutera tous les événements qu'il peut avant de revenir. Il ne reviendra que si il n'y a pas plus d'événements à gérer. Une fois qu'il retourne, vous devez appeler reset() sur le io_service avant d'appeler run() de nouveau.

    Vous pouvez avoir plusieurs threads appelant run() - ce n'est pas un problème, et vous n'avez pas besoin de la boucle infinie tant que le io_service a du travail à faire. Normal, c'est de créer un work objet sur le io_service qui va forcer run() de ne jamais revenir. Cela signifie que vous avez explicitement appel stop() sur le io_service lorsque vous avez terminé comme il ne sera jamais naturellement sortie.

    Si vous configurez un work sur le io_service, il ne sera jamais naturellement de sortie et, par conséquent, vous n'aurez plus jamais besoin d'appeler reset().

    work some_work(m_IoService); //this will keep the io_service live.

for( unsigned int i = 0; i < numThreads; ++i )
{
  m_Threads.create_thread(
    [&]()
    {
      m_IoService.run();
    });
}

    Maintenant, tous les threads sont distribution des événements sur le io_service

    //Now post your jobs
m_IoService.post(boost::bind(...)); //this will be executed in one of the threads
m_IoService.post(boost::bind(...)); //this will be executed in one of the threads
m_IoService.post(boost::bind(...)); //this will be executed in one of the threads

m_IoService.stop(); //explicitly stop the io_service
//now join all the threads and wait for them to exit