(这是我原来问题的简化版)

我有几个线程写入 boost asio 套接字。这似乎工作得很好，没有问题。

文档说共享套接字不是线程安全的(here，在底部)所以我想知道是否应该用互斥锁或其他东西保护套接字。

这个 question坚持认为保护是必要的，但没有给出如何保护的建议。

我最初的问题的所有答案也坚持认为我所做的事情很危险，并且大多数人都敦促我用 async_writes 或更复杂的东西替换我的写入。但是，我不愿意这样做，因为这会使已经运行的代码复杂化，并且没有一个回答者让我相信他们知道他们在说什么——他们似乎已经阅读了与我相同的文档并且正在猜测，就像我一样是。

所以，我编写了一个简单的程序来对从两个线程写入共享套接字进行压力测试。

这里是服务器，它简单地写出它从客户端接收到的任何内容

int main()
{
    boost::asio::io_service io_service;

    tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), 3001));

    tcp::socket socket(io_service);
    acceptor.accept(socket);

    for (;;)
    {
        char mybuffer[1256];
        int len = socket.read_some(boost::asio::buffer(mybuffer,1256));
        mybuffer[len] = '\0';
        std::cout << mybuffer;
        std::cout.flush();

    }

  return 0;
}

这里是客户端，它创建两个线程以尽可能快地写入共享套接字

boost::asio::ip::tcp::socket * psocket;

void speaker1()
{
    string msg("speaker1: hello, server, how are you running?\n");
    for( int k = 0; k < 1000; k++ ) {
        boost::asio::write(
            *psocket,boost::asio::buffer(msg,msg.length()));
    }

}
void speaker2()
{
    string msg("speaker2: hello, server, how are you running?\n");
    for( int k = 0; k < 1000; k++ ) {
        boost::asio::write(
            *psocket,boost::asio::buffer(msg,msg.length()));
    }

}

int main(int argc, char* argv[])
{

    boost::asio::io_service io_service;

  // connect to server

    tcp::resolver resolver(io_service);
    tcp::resolver::query query("localhost", "3001");
    tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
    tcp::resolver::iterator end;
    psocket = new tcp::socket(io_service);
    boost::system::error_code error = boost::asio::error::host_not_found;
    while (error && endpoint_iterator != end)
    {
        psocket->close();
        psocket->connect(*endpoint_iterator++, error);
    }


    boost::thread t1( speaker1 );
    boost::thread t2( speaker2 );

    Sleep(50000);

}

这行得通!完美，据我所知。客户端不会崩溃。消息到达服务器时没有乱码。它们通常交替到达，每个线程一个。有时一个线程在另一个线程之前收到两三条消息，但我认为这不是问题，只要没有乱码并且所有消息都到达。

我的结论:套接字在某种理论上可能不是线程安全的，但是很难让它失败，我不会担心它。

最佳答案

在重新研究 async_write 的代码后，我现在确信任何写操作都是线程安全的当且仅当数据包大小小于

default_max_transfer_size = 65536;

一旦调用 async_write，就会在同一个线程中调用 async_write_some。池中调用某种形式的 io_service::run 的任何线程将继续为该写入操作调用 async_write_some 直到它完成。

如果必须多次调用这些 async_write_some 调用(数据包大于 65536)，这些调用可以并且将会交织。

ASIO 不会像您期望的那样对套接字的写入进行排队，一个接一个地完成。为了确保 thread 和 interleave 安全写入，请考虑以下代码:

    void my_connection::async_serialized_write(
            boost::shared_ptr<transmission> outpacket) {
        m_tx_mutex.lock();
        bool in_progress = !m_pending_transmissions.empty();
        m_pending_transmissions.push(outpacket);
        if (!in_progress) {
            if (m_pending_transmissions.front()->scatter_buffers.size() > 0) {
                boost::asio::async_write(m_socket,
                    m_pending_transmissions.front()->scatter_buffers,
                        boost::asio::transfer_all(),
            boost::bind(&my_connection::handle_async_serialized_write,
                        shared_from_this(),
                        boost::asio::placeholders::error,
                                       boost::asio::placeholders::bytes_transferred));
            } else { // Send single buffer
                boost::asio::async_write(m_socket,
                                    boost::asio::buffer(
                                           m_pending_transmissions.front()->buffer_references.front(),                          m_pending_transmissions.front()->num_bytes_left),
                boost::asio::transfer_all(),
                boost::bind(
                        &my_connection::handle_async_serialized_write,
                        shared_from_this(),
                        boost::asio::placeholders::error,
                        boost::asio::placeholders::bytes_transferred));
            }
        }
        m_tx_mutex.unlock();
    }

    void my_connection::handle_async_serialized_write(
    const boost::system::error_code& e, size_t bytes_transferred) {
        if (!e) {
            boost::shared_ptr<transmission> transmission;
            m_tx_mutex.lock();
            transmission = m_pending_transmissions.front();
            m_pending_transmissions.pop();
            if (!m_pending_transmissions.empty()) {
                if (m_pending_transmissions.front()->scatter_buffers.size() > 0) {
            boost::asio::async_write(m_socket,
                    m_pending_transmissions.front()->scatter_buffers,
                    boost::asio::transfer_exactly(
                            m_pending_transmissions.front()->num_bytes_left),
                    boost::bind(
                            &chreosis_connection::handle_async_serialized_write,
                            shared_from_this(),
                            boost::asio::placeholders::error,
                            boost::asio::placeholders::bytes_transferred));
                } else { // Send single buffer
                    boost::asio::async_write(m_socket,
                    boost::asio::buffer(
                            m_pending_transmissions.front()->buffer_references.front(),
                            m_pending_transmissions.front()->num_bytes_left),
                    boost::asio::transfer_all(),
                    boost::bind(
                            &my_connection::handle_async_serialized_write,
                            shared_from_this(),
                            boost::asio::placeholders::error,
                            boost::asio::placeholders::bytes_transferred));
                }
            }
            m_tx_mutex.unlock();
            transmission->handler(e, bytes_transferred, transmission);
        } else {
            MYLOG_ERROR(
            m_connection_oid.toString() << " " << "handle_async_serialized_write: " << e.message());
            stop(connection_stop_reasons::stop_async_handler_error);
        }
    }

这基本上构成了一次发送一个数据包的队列。 async_write 仅在第一次写入成功后调用，然后调用原始处理程序进行第一次写入。

如果 asio 使每个套接字/流的写入队列自动进行，那会更容易。

关于c++ - boost::asio::socket 线程安全，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/7362894/