Warum brauche ich pro Verbindung bei boost :: asio einen Strang?

In der Dokumentation korrekt ist. Mit einer halb-duplex-Protokoll-Implementierung, wie HTTP-Server 3die strand ist nicht notwendig. Der Aufruf Ketten lassen sich wie folgt veranschaulichen:

void connection::start()
{
  socket.async_receive_from(..., &handle_read);  ----.
}                                                    |
    .------------------------------------------------'
    |      .-----------------------------------------.
    V      V                                         |
void connection::handle_read(...)                    |
{                                                    |
  if (result)                                        |
    boost::asio::async_write(..., &handle_write); --- | --.
  else if (!result)                                  |  |
    boost::asio::async_write(..., &handle_write);  -- | --|
  else                                               |  |
    socket_.async_read_some(..., &handle_read);  ----'  |
}                                                       |
    .---------------------------------------------------'
    |
    V
void handle_write(...)

Wie in der Abbildung dargestellt, nur eine einzelne asynchrone Ereignis wird gestartet, pro Weg. Ohne die Möglichkeit der gleichzeitigen Ausführung der Handler oder Operationen auf socket_es wird gesagt, die ausgeführt werden, um eine implizite Strang.

Thread-Sicherheit

Während es sich nicht als ein Problem in dem Beispiel, ich möchte hervorheben, dass ein wichtiges detail der Stränge und komponiert Operationen, wie boost::asio::async_write. Vor der Erläuterung der details, können zuerst decken Sie die thread-Sicherheit Modell mit Boost.Asio. Für die meisten Boost.Asio-Objekte, ist es sicher, um mehrere asynchrone Operationen während auf ein Objekt; es ist nur angegeben, dass Anrufe gleichzeitig auf das Objekt zu unsicher sind. In den folgenden Abbildungen repräsentiert jede Spalte einen thread und jede Zeile steht für was ein thread wird zu einem moment in der Zeit.

Ist es sicher für einen einzigen thread zu machen, sequenzielle Aufrufe, während andere threads machen keine:

 thread_1 | thread_2 
--------------------------------------+--------------------------------------- 
socket.async_receive(...); | ... 
socket.async_write_some(...); | ...

Ist es sicher für mehrere threads, um Anrufe zu tätigen, aber nicht gleichzeitig:

 thread_1 | thread_2 
--------------------------------------+--------------------------------------- 
socket.async_receive(...); | ... 
... | - Buchse.async_write_some(...);

Allerdings ist es nicht sicher für mehrere threads zu telefonieren gleichzeitig¹:

 thread_1 | thread_2 
--------------------------------------+--------------------------------------- 
socket.async_receive(...); | Buchse.async_write_some(...); 
... | ...

Stränge

Um zu verhindern, dass konkurrierende Aufrufe von Prozeduren werden oft aufgerufen wurden innerhalb der Stränge. Dies geschieht entweder durch:

• Verpackung der hf mit Strang.wrap. Das liefert einen neuen handler, wird der Versand durch den Strang.
• Posting oder Versand direkt durch den Strang.

Komponiert Operationen sind einzigartig, Zwischenstopp, um die stream sind aufgerufen, innerhalb der handler's Strang, wenn vorhanden, statt der Strang, in welchem die komponierte operation eingeleitet wird. Im Vergleich zu anderen Operationen, stellt dies eine Umkehrung, wo der Strang angegeben ist. Hier finden Sie einige Beispiel-code, mit Schwerpunkt auf strand-Nutzung, die, die demonstrieren wird, einen socket, von dem gelesen über eine nicht-bestehend aus Betrieb, und gleichzeitig geschrieben, mit einer verfassten Betrieb.

void start()
{
  //Start read and write chains.  If multiple threads have called run on
  //the service, then they may be running concurrently.  To protect the
  //socket, use the strand.
  strand_.post(&read);
  strand_.post(&write);
}

//read always needs to be posted through the strand because it invokes a
//non-composed operation on the socket.
void read()
{
  //async_receive is initiated from within the strand.  The handler does
  //not affect the strand in which async_receive is executed.
  socket_.async_receive(read_buffer_, &handle_read);
}

//This is not running within a strand, as read did not wrap it.
void handle_read()
{
  //Need to post read into the strand, otherwise the async_receive would
  //not be safe.
  strand_.post(&read);
}

//The entry into the write loop needs to be posted through a strand.
//All intermediate handlers and the next iteration of the asynchronous write
//loop will be running in a strand due to the handler being wrapped.
void write()
{
  //async_write will make one or more calls to socket_.async_write_some.
  //All intermediate handlers (calls after the first), are executed
  //within the handler's context (strand_).
  boost::asio::async_write(socket_, write_buffer_,
                           strand_.wrap(&handle_write));
}

//This will be invoked from within the strand, as it was a wrapped
//handler in write().
void handle_write()
{
  //handler_write() is invoked within a strand, so write() does not
  //have to dispatched through the strand.
  write();
}

Bedeutung von Handler-Typen

Auch innerhalb komponiert Operationen zu Steigern.Asio verwendet argument dependent lookup (ADL) zum aufrufen intermediate-Handler durch den Abschluss hf Litze. Als solche, es ist wichtig, dass die Abschluss-handler-Typ hat die entsprechenden asio_handler_invoke() Haken. Wenn der Typ auf Löschung tritt ein Typ, der nicht über die entsprechenden asio_handler_invoke() Haken, wie ein Fall, wo ein boost::function konstruiert wird, ist von der Rückgabe-Typ von strand.wrapdann ist Mittelstufe-Handler ausgeführt wird, außerhalb der strand, und nur der Abschluss-handler wird ausgeführt, innerhalb des Strangs. Sehen diese Antwort für weitere details.

In den folgenden code, alle zwischen Handler und der completion handler wird ausgeführt, innerhalb des Strang:

boost::asio::async_write(stream, buffer, strand.wrap(&handle_write));

In den folgenden code, nur der Abschluss-handler wird ausgeführt, innerhalb des Strangs. Keines der intermediate-Handler wird ausgeführt, innerhalb des Strang:

boost::function<void()> handler(strand.wrap(&handle_write));
boost::asio::async_write(stream, buffer, handler);

_{1. Die revision history Dokumente eine Abweichung von dieser Regel. Mit der Unterstützung durch das OS, synchrone Lesen, schreiben, akzeptieren und die Verbindung Operationen thread-sicher. Ich ein wie es hier der Vollständigkeit halber, aber empfehlen es mit Vorsicht.}

InformationsquelleAutor der Antwort Tanner Sansbury