问如何通过boost asio实现真正的异步客户端

EN

#include <iostream>
#include <vector>
#include <boost/asio.hpp>
#include <thread>


struct service_loop
{
    using io_service = boost::asio::io_service;

    io_service& get_io_service() {
        return _io_service;
    }

    service_loop(size_t threads = 1)
    : _strand(_io_service)
    , _work(_io_service)
    , _socket(_io_service)
    {
        for(size_t i = 0 ; i < threads ; ++i)
            add_thread();
    }

    ~service_loop() {
        stop();
    }

    // adding buffered sequential writes...

    void write(const char* data, size_t length)
    {
        _strand.dispatch([this, v = std::vector<char>(data, data + length)] {
            _write_buffer.insert(std::end(_write_buffer), v.begin(), v.end());
            check_write();
        });

    }
private:
    std::vector<char> _write_buffer;
    bool _writing;

    void check_write()
    {
        if (!_writing and !_write_buffer.empty()) {
            auto pv = std::make_shared<std::vector<char>>(std::move(_write_buffer));
            _writing = true;
            _write_buffer.clear();
            boost::asio::async_write(_socket,
                                     boost::asio::buffer(*pv),
                                     [this, pv] (const boost::system::error_code& ec, size_t written) {
                                         _strand.dispatch(std::bind(&service_loop::handle_write,
                                                                    this,
                                                                    ec,
                                                                    written));
                                     });
        }
    }

    void handle_write(const boost::system::error_code& ec, size_t written)
    {
        _writing = false;
        if (ec) {
            // handle error somehow
        }
        else {
            check_write();
        }
    }

private:
    io_service _io_service;
    io_service::strand _strand;
    io_service::work _work;
    std::vector<std::thread> _threads;
    boost::asio::ip::tcp::socket _socket;

    void add_thread()
    {
        _threads.emplace_back(std::bind(&service_loop::run_thread, this));
    }

    void stop()
    {
        _io_service.stop();
        for(auto& t : _threads) {
            if(t.joinable()) t.join();
        }
    }

    void run_thread()
    {
        while(!_io_service.stopped())
        {
            try {
                _io_service.run();
            }
            catch(const std::exception& e) {
                // report exceptions here
            }
        }
    }
};


using namespace std;

auto main() -> int
{
    service_loop sl;
    sl.write("hello", 5);
    sl.write(" world", 6);
    std::this_thread::sleep_for(std::chrono::seconds(10));

    return 0;
}