避免多线程应用程序中潜在的死锁/内存泄漏

如何解决此问题：

创建每个线程的方式是，它在允许开始用户的工作函数之前等待一个sentinel(您需要一个调用它的lambda(如果任何线程无法启动，请设置一个标志，指示现有线程应立即全部完成，而不是执行用户的功能。在出现错误的情况下，连接已启动的线程。然后根据需要退出并返回错误代码或异常(异常更好(。

现在，您的函数是线程安全的，不会泄漏内存。

编辑：这里有一些代码可以做你想做的事情，包括一个测试。如果您想强制模拟线程失败，请使用定义为1 的INTRODUCE_FAILURE重新编译

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <memory>
#include <atomic>
#include <system_error>
#include <condition_variable>
#define INTRODUCE_FAILURE 0
// implementation
void ParallelCall(void (*function)(int, int), int numThreads)
{
    std::vector<std::thread> threads;
    threads.reserve(numThreads-1);
    std::atomic<bool> mustAbort ( false );
    std::atomic<bool> mayRun ( false );
    std::mutex conditionMutex;
    std::condition_variable runCondition;
    for(int i = 1; i < numThreads; ++ i) {
        try {
            #if INTRODUCE_FAILURE == 1
            if (i == 3) {
                throw std::system_error(99, std::generic_category(),  "the test deliberately failed a thread");
            }
            #endif
            threads.emplace_back( std::thread{ [i, numThreads, function
                                , &mustAbort
                                , &conditionMutex
                                , &runCondition
                                , &mayRun]()->int {
                std::unique_lock<std::mutex> myLock(conditionMutex);
                runCondition.wait(myLock, [&mayRun]()->bool { 
                    return mayRun;
                });
                myLock.unlock();
                // wait for permission
                if (!mustAbort) {
                    function(i, numThreads);
                }
                return 0;
            }} );
        }
        catch(std::exception& e) { // will be a std::system_error
            mustAbort = true;
            std::unique_lock<std::mutex> myLock(conditionMutex);
            mayRun = true;
            conditionMutex.unlock();
            runCondition.notify_all();
            for(auto& t : threads) {
                t.join();
            }
            throw;
        }
    }
    std::unique_lock<std::mutex> myLock(conditionMutex);
    mayRun = true;
    conditionMutex.unlock();
    runCondition.notify_all();
    function(0, numThreads);
    // use the calling thread as thread 0
    for(auto& t : threads) {
        t.join();
    }
}
// test
using namespace std;
void testFunc(int index, int extent) {
    static std::mutex outputMutex;
    unique_lock<mutex> myLock(outputMutex);
    cout << "Executing " << index << " of " << extent << endl;
    myLock.unlock();
    this_thread::sleep_for( chrono::milliseconds(2000) );
    myLock.lock();
    cout << "Finishing " << index << " of " << extent << endl;
    myLock.unlock();
}
int main()
{
    try {
        cout << "initiating parallel call" << endl;
        ParallelCall(testFunc, 10);
        cout << "parallel call complete" << endl;
    }
    catch(std::exception& e) {
        cout << "Parallel call failed because: " << e.what() << endl;
    }
   return 0;
}

成功输出示例：

Compiling the source code....
$g++ -std=c++11 main.cpp -o demo -lm -pthread -lgmpxx -lgmp -lreadline 2>&1
Executing the program....
$demo 
initiating parallel call
Executing 0 of 10
Executing 1 of 10
Executing 4 of 10
Executing 5 of 10
Executing 8 of 10
Executing 2 of 10
Executing 7 of 10
Executing 6 of 10
Executing 9 of 10
Executing 3 of 10
Finishing 1 of 10
Finishing 5 of 10
Finishing 2 of 10
Finishing 9 of 10
Finishing 8 of 10
Finishing 4 of 10
Finishing 3 of 10
Finishing 0 of 10
Finishing 6 of 10
Finishing 7 of 10
parallel call complete

故障输出示例：

Compiling the source code....
$g++ -std=c++11 main.cpp -o demo -lm -pthread -lgmpxx -lgmp -lreadline 2>&1
Executing the program....
$demo 
initiating parallel call
Parallel call failed because: the test deliberately failed a thread: Cannot assign requested address

最后是一个恳求——不要把你的图书馆放在世界上。std:：线程库非常全面，如果这还不够的话，我们有OpenMP、TBB等。

让已经创建的线程在退出其threadproc之前完成丢失的工作以获得帮助如何？

List _StillBornWork;
void ParallelCall(void (*function)(int, int), int numThreads)
{
    Thread *threads = new Thread[numThreads - 1];
    for(int i = 1; i < numThreads; ++ i) {
        if(threads[i - 1].start(&function, i, numThreads)) {
            _StillBornWork.Push(i);
        }
    }
    (*function)(0, numThreads);
    // use the calling thread as thread 0
    for(int i = 1; i < numThreads; ++ i)
        threads[i - 1].join();
    delete[] threads;
}
ThreadProc(int i) {
  while(1) {
    do work
    // Here we see if there was any work that didn't get done because its thread
    // was stilborn.  In your case, the work is indicated by the integer i.
    // If we get work, loop again, else break.
    if (!_StillBornWork.Pop(&i))
      break;  // no more work that wasn't done.
  }
}