一次4000个线程是相当高的。

答案是肯定的，也不是。如果您在每个线程中执行大量阻塞I/O，那么是的，您可以在每个逻辑核心中执行3或4个线程时显示显著的加速。

If you are not doing a lot of blocking things however, then the extra overhead with threading will just make it slower. So use a profiler and see where the bottlenecks are in each possibly parallel piece. If you are doing heavy computations, then more than 1 thread per CPU won't help. If you are doing a lot of memory transfer, it won't help either. If you are doing a lot of I/O though such as for disk access or internet access, then yes multiple threads will help up to a certain extent, or at the least make the application more responsive.

我同意@Gonzalo的回答。我有一个不做I/O的进程，下面是我的发现:

请注意，所有线程都工作在一个数组上，但范围不同(两个线程不访问相同的索引)，因此如果它们工作在不同的数组上，结果可能会有所不同。

这台1.86版本的机器是一台带有SSD的macbook air。另一台mac是一台iMac，硬盘正常(我想转速是7200转)。这台装有windows操作系统的机器还有一个7200转的硬盘。

在这个测试中，最佳的数量等于机器中的核数。

我想在这里补充另一个观点。答案取决于这个问题是假设弱缩放还是强缩放。

从维基百科:

弱伸缩性:对于每个处理器的固定问题大小，解决时间如何随着处理器数量的变化而变化。

强伸缩性:对于固定的总问题规模，解决时间如何随着处理器数量的变化而变化。

If the question is assuming weak scaling then @Gonzalo's answer suffices. However if the question is assuming strong scaling, there's something more to add. In strong scaling you're assuming a fixed workload size so if you increase the number of threads, the size of the data that each thread needs to work on decreases. On modern CPUs memory accesses are expensive and would be preferable to maintain locality by keeping the data in caches. Therefore, the likely optimal number of threads can be found when the dataset of each thread fits in each core's cache (I'm not going into the details of discussing whether it's L1/L2/L3 cache(s) of the system).

即使线程数超过内核数，这也是成立的。例如，假设程序中有8个任意单位(AU)的工作将在4核机器上执行。

案例1:运行四个线程，每个线程需要完成2AU。每个线程需要10秒来完成(有很多缓存丢失)。对于四个内核，总时间为10s (10s * 4个线程/ 4个内核)。

情况2:运行8个线程，每个线程需要完成1AU。每个线程只需要2s(而不是5s，因为缓存丢失的数量减少了)。如果是四核，总时间为4s (2s * 8线程/ 4核)。

我简化了这个问题，忽略了其他答案中提到的开销(例如，上下文切换)，但希望您明白，根据您正在处理的数据大小，拥有比可用内核数量更多的线程可能是有益的。

我知道这个问题很老了，但事情从2009年开始就有了变化。

现在有两件事需要考虑:核心的数量，以及每个核心中可以运行的线程的数量。

With Intel processors, the number of threads is defined by the Hyperthreading which is just 2 (when available). But Hyperthreading cuts your execution time by two, even when not using 2 threads! (i.e. 1 pipeline shared between two processes -- this is good when you have more processes, not so good otherwise. More cores are definitively better!) Note that modern CPUs generally have more pipelines to divide the workload, so it's no really divided by two anymore. But Hyperthreading still shares a lot of the CPU units between the two threads (some call those logical CPUs).

在其他处理器上，您可能有2、4甚至8个线程。因此，如果你有8个内核，每个内核支持8个线程，你可以有64个进程并行运行，而不需要上下文切换。

“没有上下文切换”显然是不正确的，如果你运行的是一个标准的操作系统，它会对各种你无法控制的事情进行上下文切换。但这是主要的思想。一些操作系统允许你分配处理器，这样只有你的应用程序可以访问/使用处理器!

From my own experience, if you have a lot of I/O, multiple threads is good. If you have very heavy memory intensive work (read source 1, read source 2, fast computation, write) then having more threads doesn't help. Again, this depends on how much data you read/write simultaneously (i.e. if you use SSE 4.2 and read 256 bits values, that stops all threads in their step... in other words, 1 thread is probably a lot easier to implement and probably nearly as speedy if not actually faster. This will depend on your process & memory architecture, some advanced servers manage separate memory ranges for separate cores so separate threads will be faster assuming your data is properly filed... which is why, on some architectures, 4 processes will run faster than 1 process with 4 threads.)

大量线程(“线程池”)vs每个核心一个线程的一个例子是在Linux或Windows中实现web服务器。

由于在Linux中套接字是轮询的，因此许多线程可能会增加其中一个线程在正确的时间轮询正确的套接字的可能性——但总体处理成本将非常高。

在Windows中，服务器将使用I/O完成端口(IOCPs)实现，这将使应用程序事件驱动:如果I/O完成，操作系统将启动一个备用线程来处理它。当处理完成时(通常是请求-响应对中的另一个I/O操作)，线程返回IOCP端口(队列)等待下一次完成。

如果没有I/O完成，就没有要做的处理，也没有启动线程。

事实上，微软建议在IOCP实现中每个核不超过一个线程。任何I/O都可以附加到IOCP机制。如果需要，应用程序也可以发布IOCs。

理想的情况是每个内核有一个线程，只要没有线程会阻塞。

在一种情况下，这可能是不正确的:有其他线程在核心上运行，在这种情况下，更多的线程可能会给您的程序更大的执行时间。