Wie können die asynchronen Schreibvorgänge von Asio verstärkt werden, um das Verschachteln von Nachrichten zu verhindern?

Asynchrone Schreibvorgänge mit Boost Asio: Interleaving verhindern

Problemstellung:

In einer Anwendung Wenn mehrere Clients Nachrichten asynchron senden können, muss unbedingt verhindert werden, dass sich asynchrone Schreibvorgänge verschachteln. Dies kann zu einer falschen Nachrichtenreihenfolge oder verstümmelten Daten führen.

Lösung:

Eine einfache und effektive Lösung für dieses Problem besteht darin, für jeden Client eine Postausgangswarteschlange zu implementieren. Die Postausgangswarteschlange dient als Puffer für Nachrichten, die gesendet werden müssen.

Wie es funktioniert:

1. Nachrichten in die Warteschlange stellen: Wann Wenn ein Client eine Nachricht sendet, wird diese zur entsprechenden Postausgangswarteschlange hinzugefügt.
2. Initiierung Schreibvorgänge: Wenn die Postausgangswarteschlange leer ist, wird ein asynchroner Schreibvorgang initiiert, um die erste Nachricht in der Warteschlange zu senden.
3. Behandlung des Schreibabschlusses: Nachdem ein Schreibvorgang abgeschlossen ist, Die entsprechende Nachricht wird aus der Postausgangswarteschlange entfernt.
4. Überprüfen der Postausgangsgröße: Der asynchrone Schreibabschlusshandler prüft, ob die Postausgangswarteschlange noch verbleibende Nachrichten enthält. Wenn dies der Fall ist, wird sofort ein weiterer asynchroner Schreibvorgang initiiert.

Codebeispiel:

Unten finden Sie ein vereinfachtes Codebeispiel, das die Verwendung einer Postausgangswarteschlange demonstriert Schreiben verhindern Verschachtelung:

#include <boost/asio.hpp>
#include <boost/bind.hpp>

#include <deque>
#include <iostream>
#include <string>

class Connection {
public:
    Connection(boost::asio::io_service& io_service)
        : _io_service(io_service), _strand(io_service), _socket(io_service), _outbox() {}

    void write(const std::string& message) {
        _strand.post(boost::bind(&Connection::writeImpl, this, message));
    }

private:
    void writeImpl(const std::string& message) {
        _outbox.push_back(message);
        if (_outbox.size() > 1) {
            // Outstanding async_write, return
            return;
        }

        this->write();
    }

    void write() {
        const std::string& message = _outbox[0];
        boost::asio::async_write(_socket, boost::asio::buffer(message.c_str(), message.size()),
                                 _strand.wrap(boost::bind(&Connection::writeHandler, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)));
    }

    void writeHandler(const boost::system::error_code& error, const size_t bytesTransferred) {
        _outbox.pop_front();

        if (error) {
            std::cerr << "Could not write: " << boost::system::system_error(error).what() << std::endl;
            return;
        }

        if (!_outbox.empty()) {
            // More messages to send
            this->write();
        }
    }

private:
    typedef std::deque<std::string> Outbox;

private:
    boost::asio::io_service& _io_service;
    boost::asio::io_service::strand _strand;
    boost::asio::ip::tcp::socket _socket;
    Outbox _outbox;
};

Vorteile:

Dieser Ansatz bietet mehrere Vorteile:

• Stellt sicher, dass Schreibvorgänge in der Reihenfolge ausgeführt werden, in der sie ausgeführt werden werden empfangen.
• Verhindert die Verschachtelung von Nachrichten von mehreren Clients.
• Vereinfacht den Code durch Vermeidung komplexer Synchronisierungsmechanismen.

Das obige ist der detaillierte Inhalt vonWie können die asynchronen Schreibvorgänge von Asio verstärkt werden, um das Verschachteln von Nachrichten zu verhindern?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!