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

    上上篇文章演示了如何将异步调用转换为同步调用。本篇文章则演示了反过程。为何我们需要将异步调用转换为同步调用？这往往是为了获得编程的便利性——前文说过异步调用比较反人类。如果底层是异步的，转换为同步一般会损失性能。所以这种做法较少用于服务端，一般用于客户端。
    如果是体位2的异步，很简单，反复查询直到OK即可，两次查询间sleep。一般sleep时间设置为可以容忍的延迟时间。sleep时间短，则响应快（但即使你设置为sleep(0)也不可能每秒抽插超过1000次），但是cpu负载也比较大。注意如果不sleep，cpu将跑满，这可能导致工作线程更慢完成（想象下你让某人做件事，然后在一旁不停地问好了没好了没），最好不要这么做。
===============代码的分割线====================
#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;
};

#define SOME_DELAY_YOU_CAN_BEAR 10
class BlockAgainCaller{
public:
    BlockAgainCaller(){}

    string call(){ 
        CheckMeLaterCaller::Result res;
        inner.call(&res);
        while (!res.ready()){
            ::Sleep(SOME_DELAY_YOU_CAN_BEAR);
        }
        return res.getData();
    }
private:
    CheckMeLaterCaller inner;  
};
int main(){
    BlockAgainCaller cal;
    for (int i = 0; i < 5; i ++){
        cout << cal.call() << endl;
    }
    return 0;
}
===============代码的分割线====================
    如果是体位3的异步，做法也很简单，一个bool变量+条件变量即可。下面代码中ProactiveCaller::call是一个异步调用（由somefuncMaybeBlock同步调用转换得到），BlockAgainCaller::call将其再次转换成同步调用。
===============代码的分割线====================
#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 BlockAgainCaller : public ProactiveCaller::DoneHandler{
public:
    BlockAgainCaller():done_flag(false){}

    string call(){       
        boost::mutex::scoped_lock lock(mtx);
        done_flag = false;       
        inner.call(this);
        while (!done_flag)
        {
            cond.wait(lock);           
        }
        return buf;
    }

    virtual void onFinish(const string& str){
        boost::mutex::scoped_lock lock(mtx);
        buf = str;
        done_flag = true;
        cond.notify_all();
    }

private:
    ProactiveCaller inner;
    boost::mutex mtx;
    boost::condition_variable cond;
    std::string buf;
    bool done_flag;
};

int main(){
    BlockAgainCaller cal;
    for (int i = 0; i < 5; i ++){
        cout << cal.call() << endl;
    }
    return 0;
}
===============代码的分割线====================
    体位2的异步转同步简单，但是要注意每秒抽插数能否满足你的要求（小于1000次）。体位3的异步转同步，每秒抽插数的极限就高多了，一般可以达到每秒几十万-百万次这个级别（取决于所使用的条件变量的效率，可以写一个啥都不干的somefuncMaybeBlock试验看看）。