c++ - 使用 C++ 的递归线程使资源暂时不可用

Question

所以我正在尝试创建一个程序来实现一个生成随机数 (n) 的函数，并基于 n 创建 n 个线程。主线程负责打印叶子的最小值和最大值。主线程的层级深度为 3。

我写了下面的代码:

#include <iostream>
#include <thread>
#include <time.h>
#include <string>
#include <sstream>

using namespace std;


// a structure to keep the needed information of each thread
struct ThreadInfo
{
    long randomN;
    int level;
    bool run;
    int maxOfVals;
    double minOfVals;
};


// The start address (function) of the threads
void ChildWork(void* a) {

    ThreadInfo* info = (ThreadInfo*)a;

    // Generate random value n
    srand(time(NULL));
    double n=rand()%6+1;


    // initialize the thread info with n value
    info->randomN=n;
    info->maxOfVals=n;
    info->minOfVals=n;


    // the depth of recursion should not be more than 3
    if(info->level > 3)
    {
        info->run = false;
    }

    // Create n threads and run them
    ThreadInfo* childInfo = new ThreadInfo[(int)n];
    for(int i = 0; i < n; i++)
    {
        childInfo[i].level = info->level + 1;
        childInfo[i].run = true;
        std::thread tt(ChildWork, &childInfo[i]) ;
        tt.detach();
    }


    // checks if any child threads are working
    bool anyRun = true;
    while(anyRun)
    {
        anyRun = false;
        for(int i = 0; i < n; i++)
        {
            anyRun = anyRun || childInfo[i].run;
        }
    }

    // once all child threads are done, we find their max and min value
    double maximum=1, minimum=6;
    for( int i=0;i<n;i++)
    {
    //  cout<<childInfo[i].maxOfVals<<endl;


        if(childInfo[i].maxOfVals>=maximum)
            maximum=childInfo[i].maxOfVals;

        if(childInfo[i].minOfVals< minimum)
            minimum=childInfo[i].minOfVals;

    }

    info->maxOfVals=maximum;
    info->minOfVals=minimum;


    // we set the info->run value to false, so that the parrent thread of this thread will know that it is done
    info->run = false;

}

int main()
{
    ThreadInfo info;


    srand(time(NULL));
    double n=rand()%6+1;

    cout<<"n is: "<<n<<endl;

    // initializing thread info
    info.randomN=n;
    info.maxOfVals=n;
    info.minOfVals=n;
    info.level = 1;
    info.run = true;

   std::thread t(ChildWork, &info) ;
     t.join();

    while(info.run);

    info.maxOfVals= max<unsigned long>(info.randomN,info.maxOfVals);
    info.minOfVals= min<unsigned long>(info.randomN,info.minOfVals);

    cout << "Max is: " << info.maxOfVals <<" and Min is: "<<info.minOfVals;

}

代码编译没有错误，但是当我执行它时，它给了我这个:

libc++abi.dylib: terminating with uncaught exception of type std::__1::system_error: thread constructor failed: Resource temporarily unavailable Abort trap: 6

Answer 1

您生成了太多线程。它看起来有点像 fork() 炸弹。线程是非常重量级的系统资源。谨慎使用它们。

在函数 void Childwork 中，我看到两个错误:

1. 正如有人在评论中指出的那样，您检查线程的信息级别，然后创建更多线程，而不考虑之前的检查。

2. 在生成新线程的 for 循环中，您可以在生成实际线程之前增加信息级别。但是，您在此处 ThreadInfo* childInfo = new ThreadInfo[(int)n] 增加了一个新创建的 ThreadInfo 实例。 childInfo 中的所有实例的级别都为 0。基本上，您生成的每个线程的级别都是 1。

通常避免使用线程来实现 I/O 绑定(bind)操作的并发 (*)。只需使用线程来实现独立 CPU 绑定(bind)操作的并发。根据经验，您需要的线程永远不会超过系统中的 CPU 内核数 (**)。拥有更多并不会提高并发性，也不会提高性能。

(*) 您应该始终使用直接函数调用和基于事件的系统来运行伪并发 I/O 操作。您不需要任何线程来这样做。例如，TCP 服务器不需要任何线程来为数千个客户端提供服务。

(**) 这是理想情况。实际上，您的软件由多个部分组成，由独立开发人员开发并以不同模式维护，因此可以有一些理论上可以避免的线程。

多线程在 2019 年仍然是火箭科学。尤其是在 C++ 中。除非您确切地知道自己在做什么，否则不要这样做。这是一个good series of blog posts处理线程。