C++ C++；期货并行处理

我正在使用

std:：futures

来并行处理我的算法。我将信息拆分为相互排斥的池，然后在各自的线程中对每个池执行相同的操作。代码如下所示：

class Processor
{
public:
    Processor(const std::string &strVal) : m_strVal(strVal)
    {
    }

    std::string GetVal() const {return m_strVal;}

    std::vector<std::string> Do()
    {
        // do some processing - this can throw an exception
    }

private:
    std::string m_strVal;
};

class ParallelAlgo
{
private:
    std::vector<std::string> m_vecMasterResults;

public:

    ProcessingFunction(const std::vector<std::string> &vecInfo)
    {
        // vecInfo holds mutually exclusive pools

        std::vector<std::future<std::vector<std::string> > > vecFutures(vecInfo.size());

        try
        {
            for (auto n = 0 ; n < vecInfo.size() ; n++)
            {
                vecFuture[n] = std::async(std::launch::async, &ParallelAlgo::WorkFunc, vecInfo[n].GetVal());
            }

            for (auto it = vecFutures.begin() ; it != vecFutures.end() ; ++it)
            {
                std::vector<std::string> RetVal = it->get();
                m_MasterResults.insert(m_MasterResults.begin(), RetVal.begin(), RetVal.end());
                vecFutures.erase(it);
            }
        }
        catch (exception &e)
        {
            for (auto it = vecFutures.begin() ; it != vecFuture.end() ; ++it)
            {
                // race condition?
                if (it->valid())
                {
                    it->wait_for(std::chrono::second(0));
                }
            }
        }
    }

    std::vector<std::string> ParallelAlgo::WorkFunc(const std::string &strVal)
    {
        Processor _Proccessor(strVal);
        return _Processor.Do();
    }
};

类处理器
{
公众：
处理器（const std:：string和strVal）：m_strVal（strVal）
{
}
std:：string GetVal（）常量{return m_strVal；}
std:：vector Do（）
{
//进行一些处理-这可能引发异常
}
私人：
std：：字符串m_strVal；
};
类并行算法
{
私人：
标准：向量m_向量主结果；
公众：
处理函数（const std:：vector和vecInfo）
{
//vecInfo拥有互斥池
std:：vector向量期货（vecInfo.size（））；
尝试
{
用于（自动n=0；nget（）；
m_MasterResults.insert（m_MasterResults.begin（），RetVal.begin（），RetVal.end（））；
删除（它）；
}
}
捕获（例外和e）
{
for（auto it=vecfurture.begin（）；it！=vecfurture.end（）；+it）
{
//比赛条件？
如果（it->valid（））
{
它->等待（std:：chrono:：second（0））；
}
}
}
}
std:：vector parallelgo:：WorkFunc（const std:：string&strVal）
{
处理器-处理器（strVal）；
返回_Processor.Do（）；
}
};

---

我的问题是如何处理在

处理器：Do（）

中引发异常的情况？目前，我使用

future

捕获异常，然后对每个未完成的

future

等待零秒；这很好-这些线程将简单地终止，处理将不会完成。但是，我没有在catch块中引入竞争条件。

future

在调用

valid（）

和

wait_for（）

之间可能会完成，或者这不是一个问题，因为我没有对这些不完整的未来调用

get（），这对于一个完成的线程仍然是正确的，直到您调用它的
get

那里没有竞态条件。
在完成的
线程上调用
wait_for
，
完全按照预期工作，它会立即返回。我看不出有什么问题。因为你除了例外什么都不做，难道你就不能不担心未完成的线程吗？如果需要，std:：future的析构函数将阻塞直到异步处理完成，但据我所知，这是您想要的。示例代码中有一个bug。调用
vec.erase（它）
将使它失效，并且在for循环中进一步使用它是UB。我刚才问了一个类似的问题：。在我的例子中，我希望在发生错误时停止所有仍在执行的异步任务。你的问题不清楚你是否也想要，或者你是否愿意等待剩余的任务完成。