Comment empêcher l'entrelacement dans les opérations d'écriture asynchrones dans une architecture client-serveur ?

Éviter l'entrelacement dans les appels async_write

Dans une architecture client-serveur, le maintien de l'ordre des appels async_write est crucial pour garantir l'intégrité des données. Le problème survient lorsque plusieurs clients envoient des messages rapidement, provoquant l'entrelacement des opérations async_write ultérieures.

Solution : mise en file d'attente pour chaque client

Pour résoudre ce problème, il est recommandé d'employer une file d'attente sortante pour chaque client. La file d'attente sert de tampon pour les messages, garantissant qu'ils sont traités et envoyés dans le bon ordre.

Comment ça marche

1. Dès la réception du message d'un client , le serveur le met en file d'attente dans la file d'attente sortante du client.
2. Lorsque l'opération async_write pour le message en cours est terminée, le serveur inspecte la file d'attente size.
3. Si la file d'attente n'est pas vide, une nouvelle opération async_write est lancée pour envoyer le message suivant dans la file d'attente.
4. Si la file d'attente est vide, le serveur attend le message suivant pour arriver.

Exemple de code

Le code suivant illustre une implémentation de serveur avec un file d'attente sortante :

class Connection {
public:
    // ...
    void write(const std::string& message) {
        _strand.post([this, message] { writeImpl(message); });
    }

private:
    void writeImpl(const std::string& message) {
        _outbox.push(message);
        if (_outbox.size() > 1) return;
        write();
    }

    void write() {
        const std::string& message = _outbox.front();
        async_write(_socket, buffer(message), _strand.wrap(
            [this, err, bytesTransferred] { writeHandler(err, bytesTransferred); }));
    }

    void writeHandler(const std::error_code& error, size_t bytesTransferred) {
        _outbox.pop_front();
        handle error or send next message if the queue is not empty.
    }

private:
    boost::asio::strand _strand;
    std::deque<std::string> _outbox;
};

Points clés

• Chaque client a sa propre file d'attente sortante, protégée par le boost::asio::io_service::strand .
• La méthode write() est responsable de la mise en file d'attente des messages et du déclenchement de l'envoi asynchrone opérations.
• La méthode writeHandler() traite l'achèvement asynchrone de async_write et gère la file d'attente en conséquence.

En employant ces mesures, le serveur évite efficacement l'entrelacement des appels async_write, garantissant ainsi le bon ordre. de messages pour chaque client.

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!