C++ 提高asio同步与异步操作性能
这有点类似于。由于这个问题没有结论性的答案,我将发布一个类似的问题,并用示例代码和统计数据来演示这个问题 下面,我列举了同步和异步服务器应用程序示例,它们以循环的方式连续向客户机发送25字节的消息。在客户端,我正在检查它能够以什么速率接收消息。示例设置非常简单。在同步服务器的情况下,它会为每个客户端连接生成一个新线程,该线程会在循环中不断发送25字节的消息。在异步服务器的情况下,它也会为每个客户端连接生成一个新线程,该线程使用异步写入(主线程调用C++ 提高asio同步与异步操作性能,c++,boost-asio,C++,Boost Asio,这有点类似于。由于这个问题没有结论性的答案,我将发布一个类似的问题,并用示例代码和统计数据来演示这个问题 下面,我列举了同步和异步服务器应用程序示例,它们以循环的方式连续向客户机发送25字节的消息。在客户端,我正在检查它能够以什么速率接收消息。示例设置非常简单。在同步服务器的情况下,它会为每个客户端连接生成一个新线程,该线程会在循环中不断发送25字节的消息。在异步服务器的情况下,它也会为每个客户端连接生成一个新线程,该线程使用异步写入(主线程调用ioservice.run())在循环中不断发送2
ioservice.run()
)在循环中不断发送25字节的消息。对于性能测试,我只使用一个客户端
同步服务器代码:
#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();
}
}
#包括
#包括
#包括
#包括
#包括
#包括
使用boost::asio::ip::tcp;
类tcp\u连接:public boost::从\u启用\u共享\u
{
公众:
typedef boost::共享_ptr指针;
静态指针创建(boost::asio::io_服务和io_服务)
{
返回指针(新的tcp_连接(io_服务));
}
tcp::套接字和套接字()
{
返回插座;
}
void start()
{
对于(;;){
试一试{
ssize_t len=boost::asio::write(套接字,boost::asio::buffer(消息));
if(len!=消息长度(){
std::cerr这不是异步发送的使用方式:通过这种方式,连接的线程将越来越多的写入请求放入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));
}
}
void start()
{
boost::asio::异步写入(套接字),boost::asio::缓冲区(消息),
boost::bind(&tcp_connection::handle_write,shared_from_this(),
boost::asio::占位符::错误,
boost::asio::占位符::字节(已传输);
}
无效句柄写入(常量boost::system::error\u代码和错误,
大小(传输的字节数)
{
如果(错误){
if(套接字打开(){
std::虽然我自己刚刚开始ASIO,但我认为您应该从希望并行工作的每个线程执行ioservice.run()
。在同步IO的情况下,请参阅@ted,不需要调用ioservice.run()明确地。请看示例是的,正如我在原始帖子中提到的,我还怀疑性能的下降是由于ioservice线程和连接线程之间的线程切换/争用。关于ioservice线程本身调用asyn_write…我认为虽然在这个特定的示例代码中看起来不错,但在典型的使用中,case调用async_write的始终是非ioservice线程。因此,我们必须使用单个客户端发送的消息越多,与同步IO相比,异步IO似乎会增加更多的开销/性能问题。当然,这将在添加越来越多的客户端时得到补偿,因为我们不需要这样做在异步IO情况下,为每个客户端创建一个线程。我不确定您是否理解我的答案的含义。我的解决方案解决了异步低性能问题吗?开销最小,灵活性非常高。唯一的问题是,编写起来稍微麻烦一些。如果不清楚区别,我可以向an添加一些漂亮的图表回答……我想我明白你的意思了。连接线程触发对ioservice的调用,而ioservice线程则是不断尝试发送消息的线程(如果我遗漏了什么,请告诉我)。这在本示例中有效,因为_消息没有更改。但在典型情况下,该消息将在某个应用程序线程中生成,并需要发送到客户端。因此,通常ioservice线程不会调用async_write。@DonaldAlan不仅::您可以将定时事件用作。同样,事件驱动等效于执行h睡眠是让计时器回调一次又一次地点燃自己。与经典方法相比,最大的区别在于使用事件驱动循环,池中的线程可以自由执行其他回调。使用“经典方法”,线程会陷入睡眠。您还可以“立即点燃”: