核心与我可以生成的线程数之间的关系

Question

我有一个英特尔四核 CPU。

如果我要开发一个仅在我的机器上使用的 Winforms 应用程序（顺便说一句，我使用 C#），我可以生成多少个线程？

内核与我可以同时运行的最大线程数之间是否存在某种相关性？ 我是否需要查明有多少线程正在运行，如果是这样，这可能吗？ （我知道有诸如最小和最大线程之类的属性）？ 这是否取决于线程池（该池中的最大线程数是否会改变？）。 这是这篇文章/线程的 C# 部分。

Answer 1

您必须衡量。 也就是说，对于 N 个核心，我通常通过在 N+1 和 2N 线程之间生成来获得最佳结果。 但你必须衡量。

Answer 2

这一切都取决于，如果您的线程在 100% 的时间内处于活动状态（并且不等待 IO），那么每个 CPU 拥有超过 1 个线程就没有什么意义。 然而，这种情况很少发生，除非您正在执行复杂的数值计算。

.Nets线程池有： http://msdn.microsoft.com/ en-us/library/system.threading.threadpool.aspx

线程池的默认大小为
每个可用工作线程 250 个
处理器和 1000 个 I/O 完成
线程。

所以，我想说，除了：

• 测量测量测量之外，任何人都可以给你很少的建议。

在某些时候，当您添加更多线程时，由于上下文切换和同步，事情会变得更慢。

Answer 3

虽然线程和内核之间存在松散的相关性（线程真正并发执行的唯一方法是它们在单独的内核上运行，但这种知识的价值比您想象的要低），但真正的工作是由操作系统调度程序，在本例中为 Windows 中的线程调度程序。

至于可以创建多少个线程，这会因系统而异。 ThreadPool 类对生成您自己的线程没有任何限制； 它有一个在内部管理自己的线程池。 这些是您在检查 ThreadPool 类的属性时可以看到的值。 然而，这并不是说您应该生成无限的线程；而是说您应该生成无限的线程。 最终，操作系统在线程之间切换所花费的时间将多于实际允许线程运行所花费的时间。 通过基准测试找出适合您的应用程序的线程数。

你到底想做什么？

Answer 4

我可以生成多少个线程？

哇，比您想要的最佳吞吐量要多得多（数百或数千倍）。

我知道的每线程限制（在 Windows 上）是：

• 16 位线程 ID
• 用户空间堆栈的 4-8KB 分配（通常更多）
• 不可分页的内核空间上下文和堆栈，例如 16KB

Dotnet可能会为其自己的东西增加一堆每个线程的开销。 GC等。

我喜欢用于 WAG 的一个公式是：

threads = 2 * (cpu cores + active disk spindles)

最佳数字通常在其两倍之内。 的。 理论上，所需的线程与 CPU 核心成正比（出于明显的原因），但某些线程会在磁盘 I/O 上阻塞。 乘以 2 可以让 CPU 在其他线程被阻塞时有事可做。

不管怎样，从那开始并测量它。 工作线程的数量是整个问题中最容易稍后调整的部分，所以现在不要太担心。

Answer 5

只是想知道启动多个线程首先会达到什么限制。 我编写了以下简单的测试程序并尝试了它。 现在我认为内存是限制因素。 我能够运行 1000 个线程，但如果没有 Thread.Sleep() 系统会变得“有点反应迟钝”。 对于 2000 个线程，在启动大约 1800 个线程后，我遇到了内存不足异常。 （配备 Intel Core 2 Duo T5800 2.0 GHz、3.0 GiB RAM 的笔记本电脑，以及在带有 .NET Framework 3.5 SP1 的 WIndows XP SP3 上运行的“少数”应用程序）

更新

内存不足异常是由线程的堆栈。 在线程构造函数上指定堆栈大小后（我使用了 64 kB，但可能得到了我目前不知道的最小大小），我能够启动 3500 个线程（使用 Thread.Sleep() ） ）。

using System;
using System.Linq;
using System.Threading;

namespace GeneralTestApplication
{
    class Program
    {
        private static void Main()
        {
            Console.WriteLine("Enter the number of threads to start.");

            while (!Int32.TryParse(Console.ReadLine(), out Program.numberThreads)) { }

            Program.counters = new Int64[Program.numberThreads];

            Console.WriteLine("Starting {0} threads.", Program.numberThreads);

            for (Int32 threadNumber = 0; threadNumber < Program.numberThreads; threadNumber++)
            {
                new Thread(Program.ThreadMethod).Start(threadNumber);
            }

            Console.WriteLine("Press enter to perform work on all threads.");
            Console.ReadLine();

            Program.manualResetEvent.Set();

            Console.WriteLine("Press enter to stop all threads.");
            Console.ReadLine();

            Program.stop = true;

            Console.WriteLine("At least {0} threads ran.", Program.counters.Count(c => c > 0));

            Console.ReadLine();
        }

        private static Int32 numberThreads = 0;
        private static Int64[] counters = null;
        private static readonly ManualResetEvent manualResetEvent = new ManualResetEvent(false);
        private static volatile Boolean stop = false;

        public static void ThreadMethod(Object argument)
        {
            Int32 threadNumber = (Int32)argument;

            Program.manualResetEvent.WaitOne();

            while (!Program.stop)
            {
                Program.counters[threadNumber]++;

                // Uncomment to simulate heavy work.
                Thread.Sleep(10);
            }
        }
    }
}