Boost.Asio 有两种支持多线程的方式,第一种方式比较简单:在多线程的场景下,每个线程都持有一个io_service
,并且每个线程都调用各自的io_service
的run()
方法。
另一种支持多线程的方式:全局只分配一个io_service
,并且让这个io_service
在多个线程之间共享,每个线程都调用全局的io_service
的run()
方法。
让我们先分析第一种方案:在多线程的场景下,每个线程都持有一个io_service
(通常的做法是,让线程数和 CPU 核心数保持一致)。那么这种方案有什么特点呢?
io_service
所在的线程。 下面我们实现了一个AsioIOServicePool
,封装了线程池的创建操作 [完整代码]:
class AsioIOServicePool
{
public:
using IOService = boost::asio::io_service;
using Work = boost::asio::io_service::work;
using WorkPtr = std::unique_ptr;
AsioIOServicePool(std::size_t size = std::thread::hardware_concurrency())
: ioServices_(size),
works_(size),
nextIOService_(0)
{
for (std::size_t i = 0; i < size; ++i)
{
works_[i] = std::unique_ptr(new Work(ioServices_[i]));
}
for (std::size_t i = 0; i < ioServices_.size(); ++i)
{
threads_.emplace_back([this, i] ()
{
ioServices_[i].run();
});
}
}
AsioIOServicePool(const AsioIOServicePool &) = delete;
AsioIOServicePool &operator=(const AsioIOServicePool &) = delete;
// 使用 round-robin 的方式返回一个 io_service
boost::asio::io_service &getIOService()
{
auto &service = ioServices_[nextIOService_++];
if (nextIOService_ == ioServices_.size())
{
nextIOService_ = 0;
}
return service;
}
void stop()
{
for (auto &work: works_)
{
work.reset();
}
for (auto &t: threads_)
{
t.join();
}
}
private:
std::vector ioServices_;
std::vector works_;
std::vector threads_;
std::size_t nextIOService_;
};
AsioIOServicePool
使用起来也很简单:
std::mutex mtx; // protect std::cout
AsioIOServicePool pool;
boost::asio::steady_timer timer{pool.getIOService(), std::chrono::seconds{2}};
timer.async_wait([&mtx] (const boost::system::error_code &ec)
{
std::lock_guard lock(mtx);
std::cout << "Hello, World! " << std::endl;
});
pool.stop();
另一种方案则是先分配一个全局io_service
,然后开启多个线程,每个线程都调用这个io_service
的run()
方法。这样,当某个异步事件完成时,io_service
就会将相应的 event handler 交给任意一个线程去执行。
然而这种方案在实际使用中,需要注意一些问题:
strand
解决这个问题)。 下面实现了一个线程池,在每个 worker 线程中执行io_service
的run()
方法 [完整代码]:
class AsioThreadPool
{
public:
AsioThreadPool(int threadNum = std::thread::hardware_concurrency())
: work_(new boost::asio::io_service::work(service_))
{
for (int i = 0; i < threadNum; ++i)
{
threads_.emplace_back([this] () { service_.run(); });
}
}
AsioThreadPool(const AsioThreadPool &) = delete;
AsioThreadPool &operator=(const AsioThreadPool &) = delete;
boost::asio::io_service &getIOService()
{
return service_;
}
void stop()
{
work_.reset();
for (auto &t: threads_)
{
t.join();
}
}
private:
boost::asio::io_service service_;
std::unique_ptr work_;
std::vector threads_;
};
无锁的同步方式
要怎样解决前面提到的竞态条件呢?Boost.Asio 提供了io_service::strand
:如果多个 event handler 通过同一个 strand 对象分发 (dispatch),那么这些 event handler 就会保证顺序地执行。
例如,下面的例子使用 strand,所以不需要使用互斥锁保证同步了 [完整代码]:
AsioThreadPool pool(4); // 开启 4 个线程
boost::asio::steady_timer timer1{pool.getIOService(), std::chrono::seconds{1}};
boost::asio::steady_timer timer2{pool.getIOService(), std::chrono::seconds{1}};
int value = 0;
boost::asio::io_service::strand strand{pool.getIOService()};
timer1.async_wait(strand.wrap([&value] (const boost::system::error_code &ec)
{
std::cout << "Hello, World! " << value++ << std::endl;
}));
timer2.async_wait(strand.wrap([&value] (const boost::system::error_code &ec)
{
std::cout << "Hello, World! " << value++ << std::endl;
}));
pool.stop();
多线程 Echo Server
下面的EchoServer
可以在多线程中使用,它使用asio::strand
来解决前面提到的竞态问题 [完整代码]:
class TCPConnection : public std::enable_shared_from_this
{
public:
TCPConnection(boost::asio::io_service &io_service)
: socket_(io_service),
strand_(io_service)
{ }
tcp::socket &socket() { return socket_; }
void start() { doRead(); }
private:
void doRead()
{
auto self = shared_from_this();
socket_.async_read_some(
boost::asio::buffer(buffer_, buffer_.size()),
strand_.wrap([this, self](boost::system::error_code ec,
std::size_t bytes_transferred)
{
if (!ec) { doWrite(bytes_transferred); }
}));
}
void doWrite(std::size_t length)
{
auto self = shared_from_this();
boost::asio::async_write(
socket_, boost::asio::buffer(buffer_, length),
strand_.wrap([this, self](boost::system::error_code ec,
std::size_t /* bytes_transferred */)
{
if (!ec) { doRead(); }
}));
}
private:
tcp::socket socket_;
boost::asio::io_service::strand strand_;
std::array buffer_;
};
class EchoServer
{
public:
EchoServer(boost::asio::io_service &io_service, unsigned short port)
: io_service_(io_service),
acceptor_(io_service, tcp::endpoint(tcp::v4(), port))
{
doAccept();
}
void doAccept()
{
auto conn = std::make_shared(io_service_);
acceptor_.async_accept(conn->socket(),
[this, conn](boost::system::error_code ec)
{
if (!ec) { conn->start(); }
this->doAccept();
});
}
private:
boost::asio::io_service &io_service_;
tcp::acceptor acceptor_;
};
http://senlinzhan.github.io/2017/09/17/boost-asio/
##############################################
boost中asio网络库多线程并发处理实现,以及asio在多线程模型中线程的调度情况和线程安全。
io_servie 实现了一个任务队列,这里的任务就是void(void)的函数。Io_servie最常用的两个接口是post和run,post向任务队列中投递任务,run是执行队列中的任务,直到全部执行完毕,并且run可以被N个线程调用。Io_service是完全线程安全的队列。
提供的接口有run、run_one、poll、poll_one、stop、reset、dispatch、post,最常用的是run、post、stop
Io_servie是接口类,为实现跨平台,采用了策略模式,所有接口均有impl_type实现。根据平台不同impl_type分为:
1: win_iocp_io_service Win版本的实现,这里主要分析Linux版本。
2:task_io_service 非win平台下的实现,其代码结构为:
3:detail/task_io_service_fwd.hpp 简单声明task_io_service名称
4:detail/task_io_service.hpp 声明task_io_service的方法和属性
5:detail/impl/task_io_service.ipp 具体实现文件
队列中的任务类型为opertioan,原型其实是typedef task_io_service_operation operation,其实现文件在detail/task_io_service_operation.hpp中,当队列中的任务被执行时,就是task_io_service_operation:: complete被调用的时候。
Post向队列中投递任务,然后激活空闲线程执行任务。其实现流程如下:
1: Post接收handler作为参数,实际上是个仿函数,通过此仿函数构造出completion_handler对象,completion_handler继承自operation。然后调用post_immediate_completion。
2: post_immediate_completion首先将outstanding_work_增加,然后调用post_deferred_completion。
3: post_deferred_completion首先加锁将任务入列,然后调用wake_one_thread_and_unlock
4: wake_one_thread_and_unlock尝试唤醒当前空闲的线程,其实现中特别之处在于,若没有空闲线程,但是有线程在执行task->run,即阻塞在epoll_wait上,那么先中断epoll_wait执行任务队列完成后再执行epoll_wait。
5: first_idle_thread_维护了所有当前空闲线程,实际上使用了Leader/Follower模式,每次唤醒时只唤醒空闲线程的第一个。
Run方法执行队列中的所有任务,直到任务执行完毕。
1: run方法首先构造一个idle_thread_info,和first_idle_thread_类型相同,即通过first_idle_thread_将所有线程串联起来,它这个串联不是立即串联的,当该线程无任务可做是加入到first_idle_thread_的首部,有任务执行时,从first_idle_thread_中断开。这很正常,因为first_idle_thread_维护的是当前空闲线程。
2: 加锁,循环执行do_one方法,直到do_one返回false
3: do_one每次执行一个任务。首先检查队列是否为空,若空将此线程追加到first_idle_thread_的首部,然后阻塞在条件变量上,直到被唤醒。
4: 当被唤醒或是首次执行,若stopped_为true(即此时stop方法被调用了),返回0
5: 队列非空,pop出一个任务,检查队列无任务那么简单的解锁,若仍有,调用wake_one_thread_and_unlock尝试唤醒其他空闲线程执行。然后执行该任务,返回1.
6: 实际上在执行队列任务时有一个特别的判断if (o == &task_operation_),那么将会执行task_->run,task_变量类型为reactor,在linux平台实现为epoll_reactor,实现代码文件为detail/impl/epoll_reactor.ipp,run方法实际上执行的是epoll_wait,run阻塞在epoll_wait上等待事件到来,并且处理完事件后将需要回调的函数push到io_servie的任务队列中,虽然epoll_wait是阻塞的,但是它提供了interrupt函数,该interrupt是如何实现的呢,它向epoll_wait添加一个文件描述符,该文件描述符中有8个字节可读,这个文件描述符是专用于中断epoll_wait的,他被封装到select_interrupter中,select_interrupter实际上实现是eventfd_select_interrupter,在构造的时候通过pipe系统调用创建两个文件描述符,然后预先通过write_fd写8个字节,这8个字节一直保留。在添加到epoll_wait中采用EPOLLET水平触发,这样,只要select_interrupter的读文件描述符添加到epoll_wait中,立即中断epoll_wait。很是巧妙。!!!实际上就是因为有了这个reactor,它才叫io_servie,否则就是一个纯的任务队列了。
1: 有任务立即执行任务,尽量使所有的线程一起执行任务
2: 若没有任务,阻塞在epoll_wait上等待io事件
3: 若有新任务到来,并且没有空闲线程,那么先中断epoll_wait,先执行任务
4: 若队列中有任务,并且也需要epoll_wait监听事件,那么非阻塞调用epoll_wait(timeout字段设置为0),待任务执行完毕在阻塞在epoll_wait上。
5: 几乎对线程的使用上达到了极致。
6: 从这个函数中可以知道,在使用ASIO时,io_servie应该尽量多,这样可以使其epoll_wait占用的时间片最多,这样可以最大限度的响应IO事件,降低响应时延。但是每个io_servie::run占用一个线程,所以io_servie最佳应该和CPU的核数相同。
1: 加锁,调用stop_all_threads
2: 设置stopped_变量为true,遍历所有的空闲线程,依次唤醒
3: task_interrupted_设置为true,调用task_的interrupt方法
4: task_的类型为reactor,在run方法中已经做了分析
1、实现多线程方法:
其实就是多个线程同时调用io_service::run
for (int i = 0; i != m_nThreads; ++i)
{
boost::shared_ptr pTh(new boost::thread(
boost::bind(&boost::asio::io_service::run,&m_ioService)));
m_listThread.push_back(pTh);
}
2、多线程调度情况:
asio规定:只能在调用io_service::run的线程中才能调用事件完成处理器。
注:事件完成处理器就是你async_accept、async_write等注册的句柄,类似于回调的东西。
单线程:
如果只有一个线程调用io_service::run,根据asio的规定,事件完成处理器也只能在这个线程中执行。也就是说,你所有代码都在同一个线程中运行,因此变量的访问是安全的。
多线程:
如果有多个线程同时调用io_service::run以实现多线程并发处理。对于asio来说,这些线程都是平等的,没有主次之分。如果你投递的一个请求比如async_write完成时,asio将随机的激活调用io_service::run的线程。并在这个线程中调用事件完成处理器(async_write当时注册的句柄)。如果你的代码耗时较长,这个时候你投递的另一个async_write请求完成时,asio将不等待你的代码处理完成,它将在另外的一个调用io_service::run线程中,调用async_write当时注册的句柄。也就是说,你注册的事件完成处理器有可能同时在多个线程中调用。
当然你可以使用 boost::asio::io_service::strand让完成事件处理器的调用,在同一时间只有一个, 比如下面的的代码:
socket_.async_read_some(boost::asio::buffer(buffer_),
strand_.wrap(
boost::bind(&connection::handle_read, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred)));
...
boost::asio::io_service::strand strand_;
此时async_read_som完成后掉用handle_read时,必须等待其它handle_read调用完成时才能被执行(async_read_som引起的handle_read调用)。
多线程调用时,还有一个重要的问题,那就是无序化。比如说,你短时间内投递多个async_write,那么完成处理器的调用并不是按照你投递async_write的顺序调用的。asio第一次调用完成事件处理器,有可能是第二次async_write返回的结果,也有可能是第3次的。使用strand也是这样的。strand只是保证同一时间只运行一个完成处理器,但它并不保证顺序。
代码测试:
服务器:
将下面的代码编译以后,使用cmd命令提示符下传人参数
比如:test.exe 0.0.0.0 3005 10
客服端 使用windows自带的telnet
cmd命令提示符:
telnet 127.0.0.1 3005
原理:客户端连接成功后,同一时间调用100次boost::asio::async_write给客户端发送数据,并且在完成事件处理器中打印调用序号,和线程ID。
核心代码:
void start()
{
for (int i = 0; i != 100; ++i)
{
boost::shared_ptr pStr(new string);
*pStr = boost::lexical_cast(boost::this_thread::get_id());
*pStr += "\r\n";
boost::asio::async_write(m_nSocket,boost::asio::buffer(*pStr),
boost::bind(&CMyTcpConnection::HandleWrite,shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred,
pStr,i)
);
}
}
//去掉 boost::mutex::scoped_lock lk(m_ioMutex); 效果更明显。
void HandleWrite(const boost::system::error_code& error
,std::size_t bytes_transferred
,boost::shared_ptr pStr,int nIndex)
{
if (!error)
{
boost::mutex::scoped_lock lk(m_ioMutex);
cout << "发送序号=" << nIndex << ",线程id=" << boost::this_thread::get_id() << endl;
}
else
{
cout << "连接断开" << endl;
}
}
完整代码:
#include
#include
#include
#include
#include
#include
#include
#include
#include
using std::cout;
using std::endl;
using std::string;
using boost::asio::ip::tcp;
class CMyTcpConnection
: public boost::enable_shared_from_this
{
public:
CMyTcpConnection(boost::asio::io_service &ser)
:m_nSocket(ser)
{
}
typedef boost::shared_ptr CPMyTcpCon;
static CPMyTcpCon CreateNew(boost::asio::io_service& io_service)
{
return CPMyTcpCon(new CMyTcpConnection(io_service));
}
public:
void start()
{
for (int i = 0; i != 100; ++i)
{
boost::shared_ptr pStr(new string);
*pStr = boost::lexical_cast(boost::this_thread::get_id());
*pStr += "\r\n";
boost::asio::async_write(m_nSocket,boost::asio::buffer(*pStr),
boost::bind(&CMyTcpConnection::HandleWrite,shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred,
pStr,i)
);
}
}
tcp::socket& socket()
{
return m_nSocket;
}
private:
void HandleWrite(const boost::system::error_code& error
,std::size_t bytes_transferred
,boost::shared_ptr pStr,int nIndex)
{
if (!error)
{
boost::mutex::scoped_lock lk(m_ioMutex);
cout << "发送序号=" << nIndex << ",线程id=" << boost::this_thread::get_id() << endl;
}
else
{
cout << "连接断开" << endl;
}
}
private:
tcp::socket m_nSocket;
boost::mutex m_ioMutex;
};
class CMyService
: private boost::noncopyable
{
public:
CMyService(string const &strIP,string const &strPort,int nThreads)
:m_tcpAcceptor(m_ioService)
,m_nThreads(nThreads)
{
tcp::resolver resolver(m_ioService);
tcp::resolver::query query(strIP,strPort);
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query);
m_tcpAcceptor.open(endpoint.protocol());
m_tcpAcceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
m_tcpAcceptor.bind(endpoint);
m_tcpAcceptor.listen();
StartAccept(); //开始监听
}
~CMyService(){Stop();}
public:
void Stop()
{
m_ioService.stop();
for (std::vector>::const_iterator it = m_listThread.cbegin();
it != m_listThread.cend(); ++ it)
{
(*it)->join();
}
}
void Start()
{
for (int i = 0; i != m_nThreads; ++i)
{
//创建m_nThreads多线程run
boost::shared_ptr pTh(new boost::thread(
boost::bind(&boost::asio::io_service::run,&m_ioService)));
m_listThread.push_back(pTh);
}
}
private:
//这时 m_nThreads多线程就会处理网络事件
void HandleAccept(const boost::system::error_code& error
,boost::shared_ptr newConnect)
{
if (!error)
{
newConnect->start();
}
StartAccept();
}
void StartAccept()
{
CMyTcpConnection::CPMyTcpCon newConnect = CMyTcpConnection::CreateNew(m_tcpAcceptor.get_io_service());
m_tcpAcceptor.async_accept(newConnect->socket(),
boost::bind(&CMyService::HandleAccept, this,
boost::asio::placeholders::error,newConnect));
}
private:
boost::asio::io_service m_ioService;
boost::asio::ip::tcp::acceptor m_tcpAcceptor;
std::vector> m_listThread;
std::size_t m_nThreads;
};
int main(int argc, char* argv[])
{
try
{
if (argc != 4)
{
std::cerr << " \n";
return 1;
}
int nThreads = boost::lexical_cast(argv[3]);
CMyService mySer(argv[1],argv[2],nThreads);
mySer.Start();
getchar();
mySer.Stop();
}
catch (std::exception& e)
{
std::cerr << "Exception: " << e.what() << "\n";
}
return 0;
}
测试发现和上面的理论是一致的,发送序号是乱的,线程ID也不是同一个。
asio多线程中线程的合理个数:
作为服务器,在不考虑省电的情况下,应该尽可能的使用cpu。也就是说,为了让cpu都忙起来,你的线程个数应该大于等于你电脑的cpu核心数(一个核心运行一个线程)。具体的值没有最优方案,大多数人使用cpu核心数*2 + 2的这种方案,但它不一定适合你的情况。
asio在windows xp等系统中的实现:
asio在windows下使用完成端口,如果你投递的请求没有完成,那么这些线程都在等待GetQueuedCompletionStatus的返回,也就是等待内核对象,此时线程是不占用cpu时间的。
########################################
boost::asio::io_service和io_service::work和boost::thread_group配合使用
//注释中的Page是指:Boost程序库完全开发指南(第三版)
#include
//Page542: 在头文件前定义此宏,它就会向标准流cerr输出运行日志。
//#define BOOST_ASIO_ENABLE_HANDLER_TRACKING
#include
#include
long boost_thread_id_to_long(boost::thread::id id)
{
std::stringstream ss; ss << id;
return strtol(std::string(ss.str()).c_str(), (char**)NULL, 16);
}
#include
std::string local_time_to_simple_string()
{
boost::posix_time::ptime ptm = boost::posix_time::microsec_clock::local_time();
return boost::posix_time::to_simple_string(ptm);
}
#include
std::string completion_handler_fun(float f, std::string str)
{
str = (boost::format("%|s|, thread_id=%|ld|, f=%|.3f|, str=%|s|")
% local_time_to_simple_string()
% boost_thread_id_to_long(boost::this_thread::get_id())
% f % str.c_str()).str();
std::cout << str << std::endl;
return str;
}
int main1()
{
boost::asio::io_service io;
io.post(boost::bind(completion_handler_fun, 3.141592653f, "111"));
io.post(boost::bind(completion_handler_fun, 3.141592653f, "222"));
std::cout << "sleep some seconds before run" << std::endl;
boost::this_thread::sleep_for(boost::chrono::seconds(3));
io.run();
std::cout << "sleep some seconds after run" << std::endl;
boost::this_thread::sleep_for(boost::chrono::seconds(3));
return 0;
//在这个程序中,主线程提供了io_service::run的上下文。也可以创建一个线程,然后在这个线程里执行run函数。
//当run开始后,就执行所有的handler,如果io_service里面没有可执行的handler了,就退出run函数了。
}
int main2()
{
boost::asio::io_service io;
//请阅读Page540的io_service::work的描述。
//io_service::work会让io_service::run始终有事可做,所以不会退出run函数。
boost::asio::io_service::work wk(io);
io.post(boost::bind(completion_handler_fun, 3.141592653f, "111"));
io.post(boost::bind(completion_handler_fun, 3.141592653f, "222"));
std::cout << "sleep some seconds before run" << std::endl;
boost::this_thread::sleep_for(boost::chrono::seconds(3));
io.run();
//有io_service::work的存在,所以,即时没有可执行的handler了,也不会退出run函数。
std::cout << "io_service::run is end and will exit." << std::endl;
return 0;
}
int main3()
{
boost::asio::io_service io;
//事先在io_service里面放了100个要执行的handler。
for (int i = 0; i < 100; ++i)
{
std::stringstream ss; ss << i;
io.post(boost::bind(completion_handler_fun, 3.141592653f, std::string(ss.str())));
}
boost::thread_group th_gp;
//线程组创建3个线程,同时处理这100个handler。
for (int i = 0; i < 3; ++i)
{
boost::thread* th_ptr = th_gp.create_thread(boost::bind(&boost::asio::io_service::run, boost::ref(io)));
std::cout << "thread_group, thread_id=" << boost_thread_id_to_long(th_ptr->get_id()) << std::endl;
}
//这3个线程可能同时往屏幕上输出,所以屏幕可能会乱。
//执行完handler后,run函数退出,线程退出,thread_group的join_all会执行完毕。
th_gp.join_all();
std::cout << "will exit" << std::endl;
boost::this_thread::sleep_for(boost::chrono::seconds(3));
return 0;
}
int main()
{
boost::asio::io_service io;
//io_service::work阻止了io_service的run函数退出,所以thread_group的join_all函数会一直阻塞在那里。
boost::asio::io_service::work wk(io);
boost::thread_group th_gp;
for (int i = 0; i < 3; ++i)
{
boost::system::error_code error;
boost::thread* th_ptr = th_gp.create_thread(boost::bind(&boost::asio::io_service::run, boost::ref(io), error));
std::cout << "thread_group, thread_id=" << boost_thread_id_to_long(th_ptr->get_id()) << std::endl;
}
io.post(boost::bind(completion_handler_fun, 3.141592653f, "xxx"));
th_gp.join_all();
std::cout << "will exit" << std::endl;
boost::this_thread::sleep_for(boost::chrono::seconds(3));
return 0;
}
https://www.boost.org/doc/libs/1_41_0/doc/html/boost_asio/example/http/server3/server.cpp
http://think-async.com/Asio/Recipes
https://www.cnblogs.com/zhiranok/archive/2011/09/04/boost_asio_io_service_CPP.html