C ++应用程序可以创建多少个线程

Question

I'd like to know, how many threads can a C++ application create at most. Does OS, hardware caps and other factors influence on these bounds?

Answer 1

[C++11: 1.10/1]: [..] Under a hosted implementation, a C++ program can have more than one thread running concurrently. [..] Under a freestanding implementation, it is implementation-defined whether a program can have more than one thread of execution.

[C++11: 30.3/1]: 30.3 describes components that can be used to create and manage threads. [ Note: These threads are intended to map one-to-one with operating system threads. —end note ]

So, basically, it's totally up to the implementation & OS; C++ doesn't care!

It doesn't even list a recommendation in Annex B "Implementation quantities"! (which seems like an omission, actually).

Answer 2

C++ as language does not specify a maximum (or even a minimum beyond the one). The particular implementation can, but I never saw it done directly. The OS also can, but normally just states a lank like limited by system resources. Each thread uses up some nonpaged memory, selector tables, other bound things, so you may run out of that. If you don't the system will become pretty unresponsive if the threads actually do work.

Looking from other side, real parallelism is limited by actual cores in the system, and you shall not have too many threads. Applications that could logically spawn hundreds or thousands usually start using thread pools for good practical reasons.

Answer 3

Basically, there are no limits at your C++ application level . The number of maximum thread is more on the OS level (based on your architecture and memory available).

On Linux , there are no limit on the maximum number of thread per process. The number of thread is limited system wide. You can check the number of maximum allowed threads by doing:

cat /proc/sys/kernel/threads-max

On Windows you can use the testlimit tool to check the maximum number of thread: http://blogs.technet.com/b/markrussinovich/archive/2009/07/08/3261309.aspx

On Mac OS , please read this table to find the number of thread based on your hardware configuration

However, please keep in mind that you are on a multitasking system . The number of threads executed at the same time is limited by the total number of processor cores available . To do more things, the system tries to switch between all theses thread. Each "switch" has a performce (a few milliseconds). If your system is "switching" too much, it won't speed too much time to "work" and your overall system will be slow.

Answer 4

Generally, the limit of number of threads is the amount of memory available, but there have been systems around that have lower limits.

Unless you go mad with creating threads, it's very unlikely it will be a problem to have a limit. Creating more threads is rarely beneficial, once you reach a certain number - that number may be around the same as, or a few times higher than, the number of cores (which for real big, heavy hardware can be a few hundred these days, with 16-core processors and 8 sockets).

Threads that are CPU bound should not be more than the number of processors - nothing good comes from that.

Threads that are doing I/O or otherwise "sitting around waiting" can be higher in numbers - 2-5 per processor core seems reasonable. Given that modern machines have 8 sockets and 16 cores at the higher end of the spectrum, that's still only around 1000 threads.

Sure, it's possible to design, say, a webserver system where each connection is a thread, and the system has 10k or 20k connections active at any given time. But it's probably not the most efficient.

Answer 5

Apart from the general impracticality of having many more threads than cores, yes, there are limits. For example, a system may keep a unique "process ID" for each thread, and there may be only 65535 of them available. Also, each thread will have its own stack, and those stacks will eventually consume too much memory (you can however adjust the size of each stack when you spawn threads).

Here's an informative article--ignore the fact that it mentions Windows, as the concepts are similar on other common systems: http://blogs.msdn.com/b/oldnewthing/archive/2005/07/29/444912.aspx

Answer 6

There is nothing in the C++ standard that limits number of threads. However, OS will certainly have a hard limit.

Having too many threads decreases the throughput of your application, so it's recommended that you use a thread pool.

Answer 7

I'd like to know, how many threads can a C++ application create at most.

Implementation/OS-dependent.

Keep in mind that there were no threads in C++ prior to C++11.

Does OS, hardware caps and other factors influence on these bounds?

Yes.

OS might be able limit number of threads a process can create.
OS can limit total number of threads running simultaneously (to prevent fork bombs, etc, linux can definitely do that).
Available physical(and virtual) memory will limit number of threads you can create IF each thread allocates its own stack.
There can be a (possibly hardcoded) limit on how many thread "handles" OS can provide.
Underlying OS/platform might not have threads at all (real-mode compiler for DOS/FreeDOS or something similar).