Boost Asio 同步和异步操作的性能对比

Question

这与boost::asio异步性能有些相似。由于那个问题没有定论，我将发布一个类似的问题并附带样本代码和统计数据以演示问题。

下面是我准备的同步和异步服务器应用程序样例，它们不断循环地向客户端发送25字节的消息。在客户端端，我正在检查它接收消息的速度。该样例设置非常简单。在同步服务器情况下，它为每个客户端连接生成一个新线程，并且该线程保持循环发送25字节的消息。在异步服务器情况下，它也为每个客户端连接生成一个新线程，并且该线程使用异步写入循环发送25字节的消息（主线程调用ioservice.run()）。对于性能测试，我仅使用一个客户端。 同步服务器代码:

#include <iostream>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/asio.hpp>
#include <boost/thread.hpp>

using boost::asio::ip::tcp;

class tcp_connection : public boost::enable_shared_from_this<tcp_connection>
{
public:
    typedef boost::shared_ptr<tcp_connection> pointer;

    static pointer create(boost::asio::io_service& io_service)
    {
       return pointer(new tcp_connection(io_service));
    }

    tcp::socket& socket()
    {
        return socket_;
    }

    void start()
    {
        for (;;) {
            try {
                ssize_t len = boost::asio::write(socket_, boost::asio::buffer(message_));
                if (len != message_.length()) {
                    std::cerr<<"Unable to write all the bytes"<<std::endl;
                    break;
                }
                if (len == -1) {
                    std::cerr<<"Remote end closed the connection"<<std::endl;
                    break;
                }
            }
            catch (std::exception& e) {
                std::cerr<<"Error while sending data"<<std::endl;
                break;
            }
        }
    }

private:
    tcp_connection(boost::asio::io_service& io_service)
        : socket_(io_service),
          message_(25, 'A')
    {
    }

    tcp::socket socket_;
    std::string message_;
};

class tcp_server
{
public:
    tcp_server(boost::asio::io_service& io_service)
        : acceptor_(io_service, tcp::endpoint(tcp::v4(), 1234))
    {
        start_accept();
    }

private:
    void start_accept()
    {
        for (;;) {
            tcp_connection::pointer new_connection =
                tcp_connection::create(acceptor_.get_io_service());
            acceptor_.accept(new_connection->socket());
            boost::thread(boost::bind(&tcp_connection::start, new_connection));
        }
    }
    tcp::acceptor acceptor_;
};

int main()
{
    try {
        boost::asio::io_service io_service;
        tcp_server server(io_service);
    }
    catch (std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

异步服务器代码：

#include <iostream>
#include <string>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/asio.hpp>

#include <boost/thread.hpp>

using boost::asio::ip::tcp;

class tcp_connection
        : public boost::enable_shared_from_this<tcp_connection>
{
public:
    typedef boost::shared_ptr<tcp_connection> pointer;

    static pointer create(boost::asio::io_service& io_service)
    {
        return pointer(new tcp_connection(io_service));
    }

    tcp::socket& socket()
    {
        return socket_;
    }

    void start()
    {
        while (socket_.is_open()) {
            boost::asio::async_write(socket_, boost::asio::buffer(message_),
                boost::bind(&tcp_connection::handle_write, shared_from_this(),
                            boost::asio::placeholders::error,
                            boost::asio::placeholders::bytes_transferred));
        }
    }

private:
    tcp_connection(boost::asio::io_service& io_service)
        : socket_(io_service),
          message_(25, 'A')
    {
    }

    void handle_write(const boost::system::error_code& error,
                      size_t bytes_transferred)
    {
        if (error) {
            if (socket_.is_open()) {
                std::cout<<"Error while sending data asynchronously"<<std::endl;
                socket_.close();
            }
        }
    }

    tcp::socket socket_;
    std::string message_;
};

class tcp_server
{
public:
    tcp_server(boost::asio::io_service& io_service)
        : acceptor_(io_service, tcp::endpoint(tcp::v4(), 1234))
    {
        start_accept();
    }

private:
    void start_accept()
    {
        tcp_connection::pointer new_connection =
                tcp_connection::create(acceptor_.get_io_service());
        acceptor_.async_accept(new_connection->socket(),
                boost::bind(&tcp_server::handle_accept, this, new_connection,
                        boost::asio::placeholders::error));
    }

    void handle_accept(tcp_connection::pointer new_connection,
                       const boost::system::error_code& error)
    {
        if (!error) {
            boost::thread(boost::bind(&tcp_connection::start, new_connection));
        }

        start_accept();
    }

    tcp::acceptor acceptor_;
};

int main()
{
    try {
        boost::asio::io_service io_service;
        tcp_server server(io_service);
        io_service.run();
    }
    catch (std::exception& e) {
        std::cerr << e.what() << std::endl;
    }

    return 0;
}

客户端代码：

#include <iostream>

#include <boost/asio.hpp>
#include <boost/array.hpp>

int main(int argc, char* argv[])
{
    if (argc != 3) {
        std::cerr<<"Usage: client <server-host> <server-port>"<<std::endl;
        return 1;
    }

    boost::asio::io_service io_service;
    boost::asio::ip::tcp::resolver resolver(io_service);
    boost::asio::ip::tcp::resolver::query query(argv[1], argv[2]);
    boost::asio::ip::tcp::resolver::iterator it = resolver.resolve(query);
    boost::asio::ip::tcp::resolver::iterator end;
    boost::asio::ip::tcp::socket socket(io_service);
    boost::asio::connect(socket, it);

//    Statscollector to periodically print received messages stats
//    sample::myboost::StatsCollector stats_collector(5);
//    sample::myboost::StatsCollectorScheduler statsScheduler(stats_collector);
//    statsScheduler.start();

    for (;;) {
        boost::array<char, 25> buf;
        boost::system::error_code error;
        size_t len = socket.read_some(boost::asio::buffer(buf), error);
//        size_t len = boost::asio::read(socket, boost::asio::buffer(buf));
        if (len != buf.size()) {
            std::cerr<<"Length is not "<< buf.size() << " but "<<len<<std::endl;
        }
//        stats_collector.incr_msgs_received();
    }
}

问题:

当客户端运行在同步服务器上时，它能够接收大约700K个消息/秒，但当它运行在异步服务器上时，性能下降到大约100K-120K个消息/秒。我知道当我们有更多的客户端时，应该使用异步IO来提高可扩展性，在上述情况下，由于我只使用了一个单一的客户端，因此异步IO的显而易见的优势并不明显。但问题是，异步IO是否预期会对单个客户端案例的性能产生如此严重的影响，或者我是否忽略了一些明显的最佳实践来使用异步IO？性能的显著下降是由于ioservice线程（在上述情况中是主线程）和连接线程之间的线程切换引起的吗？

设置: 我在Linux机器上使用BOOST 1.47。

- Donald Alan

---

虽然我自己刚开始接触ASIO，但我认为你应该从想要并行工作的每个线程中执行ioservice.run()。请参阅教程。 - ted

在同步IO的情况下，无需显式调用ioservice.run()。请参见示例链接(http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/example/cpp03/echo/blocking_tcp_echo_server.cpp)。 - Donald Alan

Answer 1

这不是异步发送的正确使用方式：这种方式会导致连接线程在asio队列中不断添加写入请求，同时调用ioservice.run()的线程正在将它们出队。

低性能很可能是由于主线程（生产者）和运行ioservice的线程（消费者）在ioservice工作队列上存在高争用率所致。

此外，如果监视内存，您应该看到它在增长，最终可能会阻塞系统：我预计生产者比消费者更快。

正确的方法（未经测试），只报告两个相关方法，应该是这样的：

    void start()
    {
        boost::asio::async_write(socket_, boost::asio::buffer(message_),
            boost::bind(&tcp_connection::handle_write, shared_from_this(),
                        boost::asio::placeholders::error,
                        boost::asio::placeholders::bytes_transferred));
    }

    void handle_write(const boost::system::error_code& error,
                      size_t bytes_transferred)
    {
        if (error) {
            if (socket_.is_open()) {
                std::cout<<"Error while sending data asynchronously"<<std::endl;
                socket_.close();
            }
        }
        if (socket_.is_open()) {
            boost::asio::async_write(socket_, boost::asio::buffer(message_),
                boost::bind(&tcp_connection::handle_write, shared_from_this(),
                            boost::asio::placeholders::error,
                            boost::asio::placeholders::bytes_transferred));
        }

    }    

也就是说，连接线程只会"点燃"一个事件驱动循环，这个循环在ioservice的线程中运行：一旦进行写操作，回调函数就会被调用以便发布下一个写操作。

- Sigi

---

是的，正如我在原帖中提到的那样，我也怀疑性能下降是由于ioservice线程和连接线程之间的线程切换/争用所致。关于ioservice线程本身调用asyn_write...我认为虽然在这个特定的示例代码中看起来很好，但在典型的用例中，总是非ioservice线程调用async_write。 - Donald Alan

因此，当我们需要使用单个客户端发送更多的消息时，与同步IO相比，异步IO似乎会增加更多的开销/性能问题。当然，随着越来越多的客户端加入，这种情况将得到补偿，因为在异步IO情况下，我们不需要为每个客户端创建一个线程。 - Donald Alan

我想我明白你的意思了。连接线程触发对ioservice的调用，而ioservice线程则是不断尝试发送消息的线程（如果我漏掉了什么，请告诉我）。这在这个示例中可以工作，因为_message没有改变。但在典型情况下，消息将在某个应用程序线程中生成，并且需要将其发送到客户端。因此，通常ioservice线程不会调用async_write。 - Donald Alan

但是在boost asio中没有类似于Java NIO的通知写操作已完成的功能。这里唯一触发事件处理程序的方法是实际异步尝试发送一些数据到套接字上（所以ioservice线程和应用程序线程都会执行async_write，对吗？这是可取的吗）。 - Donald Alan

@DonaldAlan 不仅如此：您还可以使用定时事件，例如http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/tutorial/tuttimer3.html。再次强调，使用*事件驱动*循环执行休眠的等效方法是让计时器回调自行触发。与传统方法相比，使用事件驱动循环的巨大区别在于，池中的线程可以自由地执行其他回调。而使用“传统方法”，线程会被卡在休眠状态。您还可以“立即触发”：http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/reference/spawn.html。 - Sigi