我對boost.asio的使用不深入，所以總是過了一段時(shí)間就會(huì)對它的理解上又變得模糊起來。
還是先回頭看看boost.asio的一些基礎(chǔ)知識(shí)。

ASIO攻破?。。?/a>這篇文章有一個(gè)蠻不錯(cuò)的比喻：

對于1+n模式和n+m模式，情況會(huì)復(fù)雜一些。
把boost asio io_service與 strand 分析 一文的例子拿來用，他采用了n+m模式（2+3）來驗(yàn)證strand的作用。這種模式也就是官方文檔中說的線程池模型：

Multiple threads may call the run()
function to set up a pool of threads from which the io_service
may execute handlers. All threads that are waiting in the pool are equivalent and the io_service
may choose any one of them to invoke a handler.

首先是使用了strand的版本。

#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/asio.hpp>
#include <iostream>
#include <boost/bind.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
using namespace std;
using namespace boost;
using namespace asio;

typedef boost::asio::io_service ioType;
typedef boost::asio::strand strandType;
ioType m_service;
strandType m_strand(m_service);
boost::mutex m_mutex;


void print( int fatherID)
{
//  boost::mutex::scoped_lock lock(m_mutex);
  static int count = 0;
  cout<<"fatherID "<<fatherID<<" "<<endl;
  sleep(1);
  cout<<"count "<<count++<<endl;
}

void ioRun1()
{
  while(1)
    {
      m_service.run();
    }
}
//
void ioRun2()
{
  while(1)
    {
      m_service.run();
    }
}

void print1()
{
  m_strand.dispatch(bind(print,1));
//  cout<<"over"<<endl;
}

void print2()
{
  m_strand.post(bind(print,2));
}

void print3()
{
  m_strand.post(bind(print,3));
}

int main()
{
  boost::thread t0(ioRun1);
  boost::thread t(ioRun2);
  boost::thread t1(print1);
  boost::thread t2(print2);
  boost::thread t3(print3);
  cout<<"111111"<<endl;
  t1.join();
  t2.join();
  t3.join();
  t0.join();
  t.join();
  cout<<"ads"<<endl;
  return 0;
}

最終輸出結(jié)果：

   fatherID 1 
　count 0
　fatherID 2 
　count 1
　fatherID 3 
   count 2

說明這是線程安全的！

但是 而 io_service 不能保證：更改程序：

void print1()
{
  m_service.dispatch(bind(print,1));
//  cout<<"over"<<endl;
}

void print2()
{
  m_service.post(bind(print,2));
}

void print3()
{
  m_service.post(bind(print,3));
}

輸出結(jié)果：

fatherID 3 
fatherID 2 
count 0
fatherID 1 
count 1
count 2

很顯然，這里存在并發(fā)的問題。所以strand就是為了解決這樣的問題而出現(xiàn)的。

How strands guarantee correct execution of pending events in boost.asio一文的這個(gè)回答說：

The strand manages all handlers posted to it in a FIFO queue. When the queue is empty and a handler is posted to the strand, then the strand will post an internal handle to the io_service. Within the internal handler, a handler will be dequeued from the strand's FIFO queue, executed, and then if the queue is not empty, the internal handler posts itself back to the io_service.

翻譯過來，就是說strand使用一個(gè)FIFO隊(duì)列來管理handlers（也就是函數(shù)對象）。

asio::async_write and strand的問題是，
asio::async_write(m_socket, asio::buffer(buf, bytes),
custom_alloc(m_strand.wrap(custom_alloc(_OnSend))));

Does this code guarantee that all asynchronous operation handlers(calls to async_write_some) inside async_write are called through strand? (or it's just for my_handler?)

Tanner Sansbury的回答很細(xì)致：
With the following code:

asio::async_write(stream, ..., custom_alloc(m_strand.wrap(...)));

For this composed operation, all calls to stream.async_write_some() will be invoked within m_strand if all of the following conditions are true:

• The initiating async_write(...) call is running within m_strand():

   assert(m_strand.running_in_this_thread());
   asio::async_write(stream, ..., custom_alloc(m_strand.wrap(...)));
  

• The return type from custom_alloc is either:

• the exact type returned from strand::wrap()

        template <typename Handler> 
        Handler custom_alloc(Handler) { ... }

• a custom handler that appropriate chains invocations of asio_handler_invoke():

        template <class Handler>
        class custom_handler
        {
        public:
          custom_handler(Handler handler)
            : handler_(handler)
          {}

          template <class... Args>
          void operator()(Args&&... args)
          {
            handler_(std::forward<Args>(args)...);
          }

          template <typename Function>
          friend void asio_handler_invoke(
            Function intermediate_handler,
            custom_handler* my_handler)
          {
            // Support chaining custom strategies incase the wrapped handler
            // has a custom strategy of its own.
            using boost::asio::asio_handler_invoke;
            asio_handler_invoke(intermediate_handler, &my_handler->handler_);
          }

        private:
          Handler handler_;
        };

        template <typename Handler>
        custom_handler<Handler> custom_alloc(Handler handler)
        {
          return {handler};
        }

See this answer for more details on strands, and this answer for details on asio_handler_invoke.