Comment les files d'attente sortantes par client peuvent-elles résoudre l'entrelacement Async_write dans Boost Asio ?

Écritures asynchrones et interactions client dans boost asio

Dans la programmation asynchrone utilisant boost asio, la gestion des interactions client simultanées peut poser des défis. Plus précisément, l'entrelacement des appels async_write peut se produire lorsque plusieurs clients envoient des messages rapidement.

Le problème : entrelacement des écritures asynchrones

Considérons un scénario dans lequel le client A envoie des messages au client. B. Le serveur traite ces messages de manière asynchrone, en lisant la quantité de données spécifiée et en attendant d'autres données du client A. Une fois les informations traitées, le serveur envoie une réponse au client. B via async_write.

Cependant, si le client A envoie des messages à un rythme rapide, les opérations async_write pour ces messages peuvent s'entrelacer avant que le gestionnaire d'achèvement du message précédent ne soit invoqué.

Une solution : files d'attente sortantes par client

Pour résoudre ce problème, envisagez de mettre en place une file d'attente sortante pour chaque client. En vérifiant la taille de la file d'attente dans le gestionnaire d'achèvement async_write, le serveur peut déterminer si des messages supplémentaires sont disponibles pour l'envoi. Si tel est le cas, cela déclenche une autre opération async_write.

Exemple de code

L'extrait de code suivant illustre une implémentation possible à l'aide d'une file d'attente de boîte d'envoi :

class Connection {
public:
    ...
private:
    void writeImpl(const std::string& message) {
        _outbox.push_back(message);
        if (_outbox.size() > 1) {
            // Outstanding async_write
            return;
        }
        this->write();
    }

    void write() {
        ... // Asynchronous write operation
    }

    void writeHandler(const boost::system::error_code& error, const size_t bytesTransferred) {
        _outbox.pop_front();
        if (error) {
            // Handle error
            ...
        }
        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;
};

Points clés

• Le boost::asio::io_service::strand protège l'accès simultané à la file d'attente de la boîte d'envoi par client.
• La méthode write() est invoquée à partir du gestionnaire writeImpl() car elle est publique.

En implémentant des files d'attente sortantes par client, vous pouvez empêcher efficacement l'entrelacement des appels async_write, garantissant ainsi que les messages sont traités dans l'ordre prévu.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!