终止调用递归 C++ 多线程

Question

我是线程的新手，我遇到了让我困惑的情况，我尝试在放入线程的函数中抛出异常，并且在 main() 函数中我有一个 try 和 catch 块，但是我仍然收到这些错误：

1. terminate called after throwing an instance of 'char const*'

2. terminate called recursively

下面是我的代码

mutex m;

void AccumulateRange(uint64_t &sum, uint64_t start, uint64_t end) {
    for (uint64_t i = start;i<end;++i){
        sum+=i;
        if (sum>10) 
            throw "Number Exceed";
    }
}

int main(){

    const uint64_t num_threads = 1000;
    uint64_t nums = 1000*1000*1000;
    vector<uint64_t> v(num_threads);
    vector<thread> threads;
    uint64_t steps = nums/num_threads;

    for (uint64_t i = 0;i<num_threads;++i){
        try{
            threads.push_back(thread(AccumulateRange,ref(v[i]),steps*i,(i+1)*steps));
        }
        catch (const char& exception){
            cout<<exception<<endl;
        }
    }
    for (auto &t : threads){
        if (t.joinable())
           t.join();    
    }
    uint64_t total = accumulate(begin(v),end(v),0);
    return 0;
}

提前致谢 ！

Answer 1

详细说明@DeltA 答案：std::thread您可以使用，std::future而不是使用指针处理和传递异常，因为它将抛出的异常存储在其共享状态中：

void AccumulateRange(uint64_t& sum, uint64_t start, uint64_t end)
{
    for (uint64_t i = start; i < end; ++i)
    {
        sum += i;
        if (sum > 10)
            throw std::runtime_error("Number Exceed");
    }
}

int main()
{
    const uint64_t num_threads = 1000;
    uint64_t nums = 1000 * 1000 * 1000;
    std::vector<uint64_t> v(num_threads);
    std::vector<std::future<void>> futures;
    uint64_t steps = nums / num_threads;
    for (uint64_t i = 0; i < num_threads; ++i)
    {
        futures.push_back(std::async(std::launch::async, AccumulateRange, std::ref(v[i]), steps * i, (i + 1) * steps));
    }
    for (auto& f : futures)
    {
        try
        {
            f.get();
        }
        catch (const std::exception& e)
        {
            std::cout << e.what() << std::endl;
        }
    }
}