C++中system()调用的子进程线程数是否受标准库限制？

我用C++ thread库给程序创建多线程，每个线程里通过system()命令调用一个本身是多线程的可执行程序。想咨询：

1. 这个被调用的可执行程序能用的线程数有没有限制？
2. C++线程库或标准库有没有相关规则限制system()启动的子进程的线程使用？

parallel.h 内容 #

#ifndef parallel_h
#define parallel_h

#include <vector>
#include <functional>
#include <atomic>
#include <thread>

#include "progress_bar.h"

//simple thread pool implementation
//updateFun should be thread-safe!
template <class T>
void processInParallel(const std::vector<T>& scheduledTasks,  
                       std::function<void(const T&)> updateFun,
                       size_t maxThreads, bool progressBar)
{
    if (scheduledTasks.empty()) return;

    std::atomic<size_t> jobId(0);
    ProgressPercent progress(scheduledTasks.size());
    if (progressBar) progress.advance(0);

    auto threadWorker = [&jobId, &scheduledTasks, &updateFun,
                         &progress, progressBar]()
    {
        while (true)
        {
            size_t expected = 0;
            while(true)
            {
                expected = jobId;
                if (jobId == scheduledTasks.size())
                {
                    return;
                }
                if (jobId.compare_exchange_weak(expected, expected + 1))
                {
                    break;
                }
            }
            updateFun(scheduledTasks[expected]);
            if (progressBar) progress.advance();
        }
    };

    std::vector<std::thread> threads(std::min(maxThreads,
                                              scheduledTasks.size()));
    for (size_t i = 0; i < threads.size(); ++i)
    {
        threads[i] = std::thread(threadWorker);
    }
    for (size_t i = 0; i < threads.size(); ++i)
    {
        threads[i].join();
    }
}

#endif /* parallel_h */

main.cpp 内容 #

#include "parallel.h"
#include <iostream>
#include <functional>
#include <vector>

int main(int argc, char** argv){
    std::vector<int> jobids = {1,2,3,4,5};
    std::function<void(const int& jobid)>testfunc = [](const int& jobid)
    {
        system("Call another executable program here!");
    };
    size_t threadnum = 5;
    processInParallel(jobids, testfunc, threadnum, true);
         
}

（注：代码中progress_bar.h仅用于显示进度条，可忽略）

1. C++标准库无相关限制
   C线程库和标准库（包括system()函数）没有任何规则限制system()启动的子进程的线程数量。C标准只定义了这些API的行为逻辑，不涉及操作系统层面的资源管控。

2. 实际限制来自这几个层面

• 操作系统层面：不同操作系统会对进程的线程数有硬限制。比如Linux下可通过ulimit -u查看/修改单个进程的最大线程数；Windows下每个线程默认有几MB的栈空间，进程的虚拟内存总量会限制能创建的线程总数。
• 被调用程序自身：如果这个可执行程序内部有硬编码的线程数上限（比如固定创建4个线程），或者通过配置文件限制了线程数，那才会影响它的可用线程数。
• 系统整体资源：即使没有硬限制，当线程数远超CPU核心数时，会导致频繁的上下文切换，反而降低运行效率；同时过多线程会占用大量内存（每个线程的栈空间），可能触发内存不足的问题。

3. 补充说明
   system()本质是通过系统shell启动独立的子进程，子进程和父进程的线程池是完全独立的实体，父进程的线程数量不会对子进程的线程使用造成任何限制。

内容的提问来源于stack exchange，提问作者xin king