如何将同步调用转换成异步调用

      同步/非同步本来是IO方面的概念，不过我们可以把函数乃至各种RPC理解成一种IO设备，这样就可以把这两个词扩展到函数调用领域了。同步的函数调用指的是当函数调用返回的时候，需要函数干的事已经完成。而异步调用则没有这个保证，工作可能在函数返回前完成，也可能在之后某个时刻。
      同步/异步很容易跟阻塞/非阻塞混淆起来。严格说起来它们是有区别的：阻塞的调用指的是当前提满足的时候干活，不满足的时候等到满足为止；非阻塞则是前提满足的时候干活，不满足的时候立刻返回错误。不过很多时候，异步调用会表现出“非阻塞”的特征——不是真正的非阻塞，但由于很快返回（一般小于1us），所以在某种程度上可以被视为非阻塞（耗时短）的调用。在很多接口描述文档里，非阻塞其实说的是异步。在函数调用领域，一般情况下没有必要去严格区分异步和非阻塞。
      说来奇怪，我们天生就懂异步——比如你问隔壁几点的时候，不会两眼无神，整个人都斯巴达，等到回答后才恢复神智。但是编写/使用异步函数却会让大多数程序员感到痛苦不堪。
      为什么我们需要异步调用这个反人类的东西？本质原因在于有时候我们需要用少数线程来执行多个并行route，同时又要求低响应延迟。对于熟悉图形界面开发的人来说，应该都知道不能在事件响应函数里执行长耗时的任务，否则在函数执行完之前，整个界面将失去响应。这是因为大多数图形界面sdk都是用一个线程（为什么不用多个线程？还真有人试过，好像记得是早期的AWT，结果满地找牙。现在公认的最佳实践就是用唯一线程）来处理各种输入，产生事件并调用响应函数。如果这个线程在进行某个长时间的操作，界面失去响应就不足为奇了。又比如select/epoll/iocp服务器，采用这些API的服务，一个网络线程往往同时服务成千上万个连接。如果某个连接上的处理花费了过长时间，则这段时间内其他连接也同样无法得到响应。客户端界面失去响应1-2s，一般还是可以接受的，但服务器（比如网游）就不大好说了。所以需要避免在事件处理线程中执行会阻塞或者耗时过长的操作。为了这个目的，将同步调用转换成异步调用是最常用手段了。
      其实同步调用与异步调用很容易进行转换：如果想要把一个同步调用转换成异步调用，只需要一个线程或一组线程加上消息队列即可。根据异步调用处理工作完成的方式，可以将其细分成三类：1）甩手掌柜，不管；2）做个标记，让调用者需要时询问。“帮我买个馒头”- “馒头买好了没有？”- “馒头买好了没有？”3）直接回调，如“帮我买个馒头，买好后放在我包里”。下面的代码演示了如何将一个同步调用转换成后两类异步调用（第一类太没难度，不够niubility，忽略）
===================体位2的分隔线=====================
#include <iostream>
#include <string>
#include <queue>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
#include <windows.h>      //      只用到Sleep函数

using namespace std;

string somefuncMaybeBlock(){
      string str;
      getline(cin, str);
      return str;      //      如果是未采用隐式数据共享的std实现，这句话比较低效，但无妨，此例只是演示体位变换
}
class CheckMeLaterCaller{
public:
      class Result{
      public:
            Result()
                  : ready_flag(false){
            }
            void setData(const string& res){
                  boost::mutex::scoped_lock lock(mtx);
                  result = res;
                  ready_flag = true;
            }
            string getData(){
                  boost::mutex::scoped_lock lock(mtx);
                  return result;
            }
            bool ready(){
                  boost::mutex::scoped_lock lock(mtx);
                  return ready_flag;
            }
      private:
            string result;
            bool ready_flag;
            boost::mutex mtx;
      };
      void call(Result* result){
            boost::mutex::scoped_lock(mtx);
            queue.push(result);
            if (queue.size() == 1){
                  cond.notify_all();
            }           
      }
      CheckMeLaterCaller(){
            running_flag = true;
            grp.create_thread(boost::bind(&CheckMeLaterCaller::run, this));
      }
      ~CheckMeLaterCaller(){
            {
                  boost::mutex::scoped_lock lock(mtx);
                  running_flag = false;
                  cond.notify_all();
            }
            grp.join_all();
      }
private:
      void run(){
            while (true){
                  Result* res = NULL;
                  {
                        boost::mutex::scoped_lock lock(mtx);
                        while (running_flag && queue.empty()){
                              cond.wait(lock);                       
                        }
                        if (!running_flag){
                              return;
                        }
                        res = queue.front();
                        queue.pop();
                  }
                  if (res){
                        string tmp = somefuncMaybeBlock();
                        res->setData(tmp);
                  }                 
            }
      }           
      boost::mutex mtx;
      boost::condition_variable cond;
      std::queue<Result*> queue;
      bool running_flag;
      boost::thread_group grp;
};
int main(void) {
      CheckMeLaterCaller::Result rs[5];
           
      CheckMeLaterCaller cal;
      cal.call(&rs[0]);
      cal.call(&rs[1]);
      cal.call(&rs[2]);
      cal.call(&rs[3]);
      cal.call(&rs[4]);

      for (int i = 0; i < 5; i ++){
            while (!rs[i].ready()) {
                  ::Sleep(10);
            }
            cout << rs[i].getData() << endl;
      }     
      return 0;
}
===================体位3的分隔线=====================
#include <iostream>
#include <string>
#include <queue>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
#include <windows.h>      //      只用到Sleep函数

using namespace std;

string somefuncMaybeBlock(){
      string str;
      getline(cin, str);
      return str;      //      如果是未采用隐式数据共享的std实现，这句话比较低效，但无妨，此例只是演示体位变换
}
class ProactiveCaller{
public:
      class DoneHandler
      {
      public:
            virtual void onFinish(const string& str) = 0;
            virtual ~DoneHandler(){}
      };
      void call(DoneHandler* handler){
            boost::mutex::scoped_lock(mtx);
            queue.push(handler);
            if (queue.size() == 1){
                  cond.notify_all();
            }           
      }     
      ProactiveCaller(){
            running_flag = true;
            grp.create_thread(boost::bind(&ProactiveCaller::run, this));
      }
      ~ProactiveCaller(){
            {
                  boost::mutex::scoped_lock lock(mtx);
                  running_flag = false;
                  cond.notify_all();
            }
            grp.join_all();
      }
private:
      void run(){
            while (true){
                  DoneHandler* handler = NULL;
                  {
                        boost::mutex::scoped_lock lock(mtx);
                        while (running_flag && queue.empty()){
                              cond.wait(lock);                       
                        }
                        if (!running_flag){
                              return;
                        }
                        handler = queue.front();
                        queue.pop();
                  }
                  if (handler){
                        string tmp = somefuncMaybeBlock();
                        handler->onFinish(tmp);
                  }                 
            }
      }     
     
      boost::mutex mtx;
      boost::condition_variable cond;
      std::queue<DoneHandler*> queue;
      bool running_flag;
      boost::thread_group grp;     
};
class PrintHandler : public ProactiveCaller::DoneHandler{
public:
      PrintHandler(): cnt(0){}
      virtual void onFinish(const string& str){
            boost::mutex::scoped_lock lock(mtx);
            cout << str << endl;
            ++ cnt;
      }
      int getCnt(){
            boost::mutex::scoped_lock lock(mtx);
            return cnt;
      }
private:
      boost::mutex mtx;
      int cnt;
};
int main(void) {     
      PrintHandler handler;
      ProactiveCaller cal;
      for (int i = 0; i < 5; i ++){
            cal.call(&handler);
      }     
      while (handler.getCnt() != 5) {
            ::Sleep(10);
      }     
      return 0;
}