我正在学习使用 Boost ASIO。这是从 chat example 复制的一些代码与 Boost ASIO 文档一起提供，

typedef std::deque<chat_message> chat_message_queue;

class chat_client
{
    public:
        chat_client(boost::asio::io_service& io_service,
                tcp::resolver::iterator endpoint_iterator)
            : io_service_(io_service),
            socket_(io_service)
    {
        boost::asio::async_connect(socket_, endpoint_iterator,
                boost::bind(&chat_client::handle_connect, this,
                    boost::asio::placeholders::error));
    }

        void write(const chat_message& msg)
        {
            io_service_.post(boost::bind(&chat_client::do_write, this, msg));
        }

        void close()
        {
            io_service_.post(boost::bind(&chat_client::do_close, this));
        }

    private:

        void handle_connect(const boost::system::error_code& error)
        {
            //Implementation
        }

        void handle_read_header(const boost::system::error_code& error)
        {
            //Implementation
        }

        void handle_read_body(const boost::system::error_code& error)
        {
            //Implementation
        }

        void do_write(chat_message msg)
        {
            bool write_in_progress = !write_msgs_.empty();
            write_msgs_.push_back(msg);
            if (!write_in_progress)
            {
                boost::asio::async_write(socket_,
                        boost::asio::buffer(write_msgs_.front().data(),
                            write_msgs_.front().length()),
                        boost::bind(&chat_client::handle_write, this,
                            boost::asio::placeholders::error));
            }
        }



        void handle_write(const boost::system::error_code& error)
        {
            //Implementation
        }

        void do_close()
        {
            socket_.close();
        }

    private:
        boost::asio::io_service& io_service_;
        tcp::socket socket_;
        chat_message read_msg_;
        chat_message_queue write_msgs_;
};

1. 写入是异步的，并且没有在成员变量 write_msgs_ 和 read_msgs_ 周围使用锁。这里不应该存在并发问题吗？

2. 从运行 io_service::run 的线程调用 post 是否安全？ dispatch 呢？从未运行 io_service::run 的线程发出相同的调用怎么样？

3. 在 doSend() 中，为什么他们将消息推送到 write_msgs_ 而不是直接发送？同样在同一个函数中，为什么他们要检查 write_msgs_ 是否为空，如果不是，则继续发送？ write_msgs_.empty() = false 是否意味着写入正在进行？怎么办？

4. 如果 do_write() 仅在一个线程中被调用，那么为什么我需要一个队列来维护发送序列？ io_service 不会完成手头的任务，然后执行 do_write 调用的异步操作吗？使用 dispatch 而不是 post 是否会对上述示例产生影响？

最佳答案

1. 虽然写入是异步的，但这里没有多线程:do_write() 在一个线程中被调用。当然，在调用完成处理程序之前，正在发送的缓冲区必须是事件的且不变的。

2. 从任何线程调用 post() 和 dispatch() 都是安全的。阅读 io_service documentation 的“线程安全”部分.

3. 如果 async_write 正在进行中，并且您再次在同一个套接字上调用 async_write，则发送数据的顺序是未定义的。换句话说，数据会乱七八糟。解决此问题的最简单方法是创建一个消息队列:每次 async_write 完成时，发出另一个 async_write。 (顺便说一句，这同样适用于async_read。) 为什么 write_msgs_.empty() = false 意味着写入正在进行？因为只要write_msgs_不为空，handle_write(上一个async_write的完成处理程序)就会发出另一个async_write .此循环在 write_msgs_ 为空时中断。

4. 请看一下the documentation says about async_write :

   This operation is implemented in terms of zero or more calls to the stream's async_write_some function, and is known as a composed operation. The program must ensure that the stream performs no other write operations (such as async_write, the stream's async_write_some function, or any other composed operations that perform writes) until this operation completes.

至于 dispatch 与 post - 据我所知，在上面的示例中它们是可以互换的。如果我们不希望被发布的仿函数被同步调用，那么使用发布是必不可少的。

关于c++ - boost ASIO 并发度，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/11531720/