[并发编程]使用线程安全队列和条件变量的notify来安排分步骤任务

 // 方法1：直接构建N个THread来run
 foreach (i, size)
 {
     thread trd(&Instance::doWork, &inst);
     lstTrd.push_back(trd);
 }

 foreach(lstTrd, join);

 // 方法2：使用notify的方式来处理分步骤任务

 class threadsafe_queue
 {
     queue<int> q;
     mutex m;
     condition_variable cond;
 public:
     void push(int i)
     {
         lock_guard<mutex> lk(m);
         q.push_back(i);
         cond.notify_one();
     }

     void wait_and_pop(int &i)
     {
         unique_lock<mutex> lk(m);
         cond.wait(lk, [this]{ return !q.empty(); } );
         i = q.front();
         q.pop();
     }
 }

 class Instance
 {
     // 存储原始的用于处理的n个数目的数据
     List<GDSLayer> lstInfo;
     ...
     // 存储最终的数据（其实应该每个步骤都有中间过程数据产生）
     List<Result>   lstResult;

     // 每个步骤完成就往对应的queue里面把完成的数据的index插入，而下一个线程就在等待这个队列有元素
     // 于是对于数据index = 0就会进行：A->B->C...
     threadsafe_queue merge_q;
     threadsafe_queue match_q;
     threadsafe_queue GDSPinGen_q;
     threadsafe_queue OBSGen_q;
     threadsafe_queue LEFPin_q;
 public:
     void merge_thread()
     {
         // 如果发生错误，那么是否要符合没有到size也可以退出
         // 事先是否要把所有可能的操作数的空间都分配好，免得如果先操作0，结果notify到了3，然后操作3，虽然原始数据有，但存储过程数据还没有
         // 同时，Log信息处理是否可行？中间检查信息的操作是安全的吗？
         // 但这样，每个thread只负责一个步骤，处理完一个数据才处理下一个（是否如此？）按理来说是不会存在跨越的问题
         foreach (i, lstInfo.size())
         {
             bool b_state = doMerge(lstInfo[i]);
             if (b_state)
                 merge_q.push_back(i);
         }
     }

     void match_thread()
     {
         foreach(i, lstInfo.size())
         {
             int key = -;
             merge_q.wait_and_pop(key);
             bool b_state = doMatch( lstInfo[ key ] );
             if (b_state)
             {
                 match_q.push_back( key );
             }
         }
     }

     void GDSPinGen_thread()
     {}

     void OBSGen_thread()
     {}

     void LEFPin_thread()
     {}
 }

方法3：使用async

方法4：使用package_task
 方法5：使用promise

方法6：使用线程池