Boost.Asio 有两种支持多线程的方式，第一种方式比较简单：在多线程的场景下，每个线程都持有一个 io_service ，并且每个线程都调用各自的 io_service 的 run() 方法。
另一种支持多线程的方式：全局只分配一个 io_service ，并且让这个 io_service 在多个线程之间共享，每个线程都调用全局的 io_service 的 run() 方法。

每个线程一个 I/O Service

让我们先分析第一种方案：在多线程的场景下，每个线程都持有一个 io_service (通常的做法是，让线程数和 CPU 核心数保持一致)。那么这种方案有什么特点呢？

• 在多核的机器上，这种方案可以充分利用多个 CPU 核心。
• 某个 socket 描述符 并不会 在多个线程之间共享，所以不需要引入同步机制。
• 在 event handler 中不能执行阻塞的操作，否则将会阻塞掉 io_service 所在的线程。

下面我们实现了一个 AsioIOServicePool ，封装了线程池的创建操作 [完整代码] ：

class AsioIOServicePool
public:
    using IOService = boost::asio::io_service;
    using Work = boost::asio::io_service::work;
    using WorkPtr = std::unique_ptr<Work>;
    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<Work>(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<IOService>       ioServices_;
    std::vector<WorkPtr>         works_;
    std::vector<std::thread>     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<std::mutex> lock(mtx);
                      std::cout << "Hello, World! " << std::endl;
pool.stop();
 
一个 I/O Service 与多个线程
 
　　另一种方案则是先分配一个全局io_service，然后开启多个线程，每个线程都调用这个io_service的run()方法。这样，当某个异步事件完成时，io_service就会将相应的 event handler 交给任意一个线程去执行。
 　　然而这种方案在实际使用中，需要注意一些问题：
 
在 event handler 中允许执行阻塞的操作 (例如数据库查询操作)。
线程数可以大于 CPU 核心数，譬如说，如果需要在 event handler 中执行阻塞的操作，为了提高程序的响应速度，这时就需要提高线程的数目。
由于多个线程同时运行事件循环(event loop)，所以会导致一个问题：即一个 socket 描述符可能会在多个线程之间共享，容易出现竞态条件 (race condition)。譬如说，如果某个 socket 的可读事件很快发生了两次，那么就会出现两个线程同时读同一个 socket 的问题 (可以使用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<boost::asio::io_service::work> work_;
    std::vector<std::thread> 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<TCPConnection> 
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<char, 8192> 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<TCPConnection>(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_service介绍
 
io_service的作用
 
io_servie 实现了一个任务队列，这里的任务就是void(void)的函数。Io_servie最常用的两个接口是post和run，post向任务队列中投递任务，run是执行队列中的任务，直到全部执行完毕，并且run可以被N个线程调用。Io_service是完全线程安全的队列。
 
Io_servie的接口
 
提供的接口有run、run_one、poll、poll_one、stop、reset、dispatch、post，最常用的是run、post、stop
 
Io_servie 实现代码的基本类结构：
 
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被调用的时候。
 
Io_servie::Post方法的实现
 
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模式，每次唤醒时只唤醒空闲线程的第一个。
 
Io_servie::run方法的实现
 
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，否则就是一个纯的任务队列了。
 
Run方法的原则是：
 
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的核数相同。
 
Io_servie::stop的实现
 
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<boost::thread> 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命令提示符下传人参数<IP> <port> <threads>调用
 
比如：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<string> pStr(new string);
            *pStr = boost::lexical_cast<string>(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<string> pStr,int nIndex)
        if (!error)
            boost::mutex::scoped_lock lk(m_ioMutex);
            cout << "发送序号=" << nIndex << ",线程id=" << boost::this_thread::get_id() << endl;
            cout << "连接断开" << endl;
完整代码：
 
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/asio.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <string>
#include <iostream>
using std::cout;
using std::endl;
using std::string;
using boost::asio::ip::tcp;
class CMyTcpConnection
    : public boost::enable_shared_from_this<CMyTcpConnection>
public:
    CMyTcpConnection(boost::asio::io_service &ser)
        :m_nSocket(ser)
    typedef boost::shared_ptr<CMyTcpConnection> 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<string> pStr(new string);
            *pStr = boost::lexical_cast<string>(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<string> pStr,int nIndex)
        if (!error)
            boost::mutex::scoped_lock lk(m_ioMutex);
            cout << "发送序号=" << nIndex << ",线程id=" << boost::this_thread::get_id() << endl;
            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<boost::shared_ptr<boost::thread>>::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<boost::thread> 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<CMyTcpConnection> 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<boost::shared_ptr<boost::thread>> m_listThread;
    std::size_t m_nThreads;
int main(int argc, char* argv[])
        if (argc != 4)
            std::cerr << "<IP> <port> <threads>\n";
            return 1;
        int nThreads = boost::lexical_cast<int>(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 <iostream>
//Page542: 在头文件<boost/asio.hpp>前定义此宏，它就会向标准流cerr输出运行日志。
//#define BOOST_ASIO_ENABLE_HANDLER_TRACKING
#include <boost/asio.hpp>
#include <boost/thread.hpp>  
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 <boost/date_time/posix_time/posix_time.hpp>
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 <boost/format.hpp>
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
                    Boost.Asio 有两种支持多线程的方式，第一种方式比较简单：在多线程的场景下，每个线程都持有一个io_service，并且每个线程都调用各自的io_service的run()方法。　　另一种支持多线程的方式：全局只分配一个io_service，并且让这个io_service在多个线程之间共享，每个线程都调用全局的io_service的run()方法。每个线程一个 I/O S...
				
Boost.Asio 有两种支持多线程的方式，第一种方式比较简单：在多线程的场景下，每个线程都持有一个io_service，并且每个线程都调用各自的io_service的run()方法。
　　另一种支持多线程的方式：全局只分配一个io_service，并且让这个io_service在多个线程之间共享，每个线程都调用全局的io_service的run()方法。
每个线程一个 I/O Service
　　让我们先分析第一种方案：在多线程的场景下，每个线程都持有一个io_service (通常的做法是，让线程数和 CPU 核心数保持一致)。那么这种方案有什么特点呢？
1  在多核的机器上，这种方案
				
参考资料：《Boost Asio C++网络编程》第五章
异步多线程服务端是可实际运用服务端软件的最低要求，其用于解决如下基本问题：并发服务中，有用户连接需要服务端执行耗时操作，同时不影响其他用户连接工作。
一个显然的想法是，为每个耗时用户连接开启一个工作线程进行耗时操作，在线程工作时不阻塞主线程，线程结束后执行异步回调函数。如果我们直接在工作线程末尾调用回调函数，那么回调函数会在工作线程中而不是...
#pragma once
#include <boost/asio/io_service.hpp>
#include <boost/asio/deadline_timer.hpp>
#include <network/EndpointDescription.h>
#include "IArchive.h"
#include "IPlayer.h"
#include "Convert.h"
#include <messages/Messages.h
				
基于boost.asio网络模块和protobuf通信描述的RPC实现
##1 RPC实现框架
目前实现的RPC只能一端的RPC client调用另一端的RPC service，没有返回值。如果需要返回值，另一端调用这一端的RPC，以参数作为返回值。
RPC分为client和service，client以protobuf的stub/channel形式实现，rpc server以service实现。
网络通信的服务端和客户端，都包括了RPC服务端和RPC客户端，RPC的客户端通过网络通信调用RPC服务端。
注意区分网络通信的服务端/客户端与RPC服务端/客户端，在本文中代表两种含义。
##2 模块构成：
TcpConnection：
RpcChannel子类，提供CallMethod函数。该函数用于RPC客户端调用stub的service时使用，包括function和参数信息的序列化，以及调
多个io_context对应多线程(每个线程都有一个io_context,均调用各自的run方法
一个io_context对应多线程(所有线程共用一个io_context,每个线程都调用全局的io_context.run 方法
每个线程一个 I/O Service
让我...
				
Boost Asio是一个开源的跨平台C++网络编程库，它是Boost库的一部分。它支持TCP、UDP、串行端口和其他网络协议的异步编程，是编写并发和可扩展网络应用程序的一种高效方法。使用Boost Asio，程序员可以通过简单的调用API来创建一个异步网络服务器或客户端。
Boost Asio采用事件驱动模型实现异步I/O操作，这种工作方式可以最大程度地利用系统资源，提高程序的效率。同时，它也是一种非阻塞的I/O操作方式，可以在等待I/O操作完成的同时继续进行其他任务。
Boost Asio的使用方法相对来说比较简单，可以通过阅读文档和代码示例学习。同时，Boost Asio还提供了多种异步编程的机制，例如回调函数、协程和Futures等等。这使得程序员可以根据自己的编程习惯选择适合自己的编程方式，从而更加高效地完成编码任务。
总之，Boost Asio是C++网络编程中一种功能丰富、稳定可靠的库，能够大大提高程序开发的效率和可靠性。在实际编程中，对于网络编程的初学者和有经验的程序员都是一种不可或缺的工具。