l'utilisation de plusieurs objets io_service

La question a un degré d'incertitude, comme si de multiples io_service les objets requis. J'ai pas pu trouver quoi que ce soit dans le référence de la documentation ou de l'aperçu pour les SSL et Les Sockets de Domaine UNIX que mandat distinct io_service objets. Peu importe, voici quelques options:

---

Unique io_service:

Essayez d'utiliser un seul io_service.

Si vous n'avez pas directement de la poignée pour la io_service objet, mais vous avez une poignée pour un coup de pouce.Asio I/O objet, tel qu'un socket, puis une poignée à l'associé io_service objet peut être obtenu en appelant socket.get_io_service().

---

Utiliser un thread par io_service:

Si plusieurs io_service objets sont requis, puis consacrer un thread à chaque io_service. Cette approche est utilisée dans Boost.Asio est L'adresse HTTP du Serveur 2 exemple.

boost::asio::io_service service1;
boost::asio::io_service service2;

boost::thread_group threads;
threads.create_thread(boost::bind(&boost::asio::io_service::run, &service1));
service2.run();
threads.join_all();

Une conséquence de cette approche est que l'on peut exiger de thread de garanties de sécurité pour être réalisée par l'application. Par exemple, si service1 et service2 les deux ont l'achèvement des gestionnaires qui l'invoque,message_processor.process(), puis message_processor.process() doit être thread-safe ou appelé un "thread-safe".

---

Sondage io_service:

io_service offre non-blocage des alternatives à run(). Où que io_service::run() bloquera jusqu'à ce que tout le travail est terminé, io_service::poll() va exécuter les gestionnaires sont prêts à exécuter et ne bloquera pas. Cela permet, pour un seul thread à exécuter la boucle d'événements sur plusieurs io_service objets:

while (!service1.stopped() &&
       !service2.stopped())
{
  std::size_t ran = 0;
  ran += service1.poll();
  ran += service2.poll();
  //If no handlers ran, then sleep.
  if (0 == ran)
  {
    boost::this_thread::sleep_for(boost::chrono::seconds(1));
  }
}

Pour éviter un resserrement de l'activité de la boucle quand il n'y a pas de prêt-à-exécuter les gestionnaires, il peut être intéressant d'ajouter dans un sommeil. Sachez que ce sommeil peuvent introduire des temps de latence dans la tenue de l'ensemble des événements.

---

Transfert des gestionnaires d'un seul io_service:

Une approche intéressante consiste à utiliser un strand de fin de transfert des gestionnaires d'un seul io_service. Cela permet à un thread par io_service, tout en évitant le besoin d'avoir l'application thread-les garanties de sécurité, comme tous d'achèvement des gestionnaires de poste par le biais d'un service unique, dont la boucle d'événement est seulement en cours de traitement par un seul thread.

boost::asio::io_service service1;
boost::asio::io_service service2;

//strand2 will be used by service2 to post handlers to service1.
boost::asio::strand strand2(service1);
boost::asio::io_service::work work2(service2);

socket.async_read_some(buffer, strand2.wrap(read_some_handler));

boost::thread_group threads;
threads.create_thread(boost::bind(&boost::asio::io_service::run, &service1));
service2.run();
threads.join_all();

Cette approche comporte certaines conséquences:

• Il exige des gestionnaires qui sont destinés à en a couru par les principaux io_service à être enveloppé par volet::wrap().
• Asynchrone chaîne fonctionne maintenant sur deux io_services, la création d'un niveau supplémentaire de complexité. Il est important de tenir compte du cas où le secondaire io_service n'a plus de travail, de sorte que ses run() de retour.

Il est courant pour un asynchrones chaînes à se produire dans le même io_service. Ainsi, le service n'est jamais à court de travail, en tant que gestionnaire d'achèvement sera poste de travail supplémentaire sur le io_service.

   |    .------------------------------------------.
   V    V                                          |
read_some_handler()                                |
{                                                  |
  socket.async_read_some(..., read_some_handler) --'
}

D'autre part, lorsque le fil est utilisé pour transférer de travail à l'autre io_service, enveloppés gestionnaire est appelé à l'intérieur de service2, provoquant la poste le gestionnaire d'achèvement dans service1. Si le enveloppés gestionnaire a été le seul travail dans service2, puis service2 n'a plus de travail, provoquant servce2.run() de retour.

    service1                      service2
====================================================

        .----------------- wrapped(read_some_handler)
        |                            .
        V                            .
 read_some_handler                NO WORK
        |                            .
        |                            .
        '----------------> wrapped(read_some_handler)

Pour tenir compte de cela, l'exemple de code utilise une io_service:: pour service2 de sorte que run() reste bloqué jusqu'à ce que dit explicitement pour stop().

OriginalL'auteur Tanner Sansbury