Bagaimanakah Boleh Meningkatkan Tulisan Asynchronous Asio Menghalang Persilangan Mesej?

Tulisan Asynchronous dengan Boost Asio: Mencegah Interleaving

Pernyataan Masalah:

Dalam aplikasi di mana berbilang pelanggan boleh menghantar mesej secara tak segerak, adalah penting untuk mengelakkan penulisan tak segerak operasi daripada interleaving. Ini boleh membawa kepada pesanan mesej yang salah atau data bercelaru.

Penyelesaian:

Penyelesaian yang mudah dan berkesan untuk masalah ini adalah dengan melaksanakan baris gilir peti keluar untuk setiap pelanggan. Baris gilir peti keluar berfungsi sebagai penimbal untuk mesej yang perlu dihantar.

Cara Ia Berfungsi:

1. Mesej Beratur: Bila pelanggan menghantar mesej, ia ditambah ke peti keluar yang sepadan baris gilir.
2. Memulakan Tulisan: Jika baris gilir peti keluar kosong, operasi tulis tak segerak dimulakan untuk menghantar mesej pertama dalam baris gilir.
3. Mengendalikan Tulis Penyelesaian: Selepas operasi tulis selesai, mesej yang sepadan dialih keluar daripada peti keluar baris gilir.
4. Memeriksa Saiz Peti Keluar: Pengendali siap tulis tak segerak menyemak sama ada baris gilir peti keluar mengandungi sebarang mesej yang tinggal. Jika ya, satu lagi operasi tulis tak segerak akan dimulakan serta-merta.

Contoh Kod:

Di bawah ialah contoh kod ringkas yang menunjukkan penggunaan baris gilir peti keluar untuk menghalang menulis interleaving:

#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;
};

Faedah:

Pendekatan ini memberikan beberapa faedah:

• Memastikan operasi tulis dilaksanakan mengikut susunannya diterima.
• Menghalang persilangan mesej daripada berbilang pelanggan.
• Memudahkan kod dengan mengelakkan mekanisme penyegerakan yang kompleks.

Atas ialah kandungan terperinci Bagaimanakah Boleh Meningkatkan Tulisan Asynchronous Asio Menghalang Persilangan Mesej?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!