[并发编程]使用线程安全队列和条件变量的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 = -1;
            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：使用线程池