ThreadPool 给出了惊人的结果，我这样做对吗？ （不，我没有）

Question

并不是说我不欣赏多线程或 ThreadPool 的强大功能，但我担心我会破坏某些东西，因为我的速度提高了大约 20 倍（比一分钟多缩短了 2-3 秒）相对简单地使用了ThreadPool。 因此，我在这里提交我的代码，以便被比我聪明得多的人撕碎。

我在这里做错了什么，还是这只是比我希望的更好的多线程候选者？ （是的，这个函数是一个完整的线程：就像我说的，这过去需要一分钟多的时间才能运行）

编辑：要回答我自己的问题，不，这已经损坏了：它似乎正在运行多次，但在同一个触发器上。 这是因为 lambda 的处理方式吗？

private static void CompileEverything()
{
    try
    {
        // maintain the state of our systray icon
        object iconLock = new object();
        bool iconIsOut = true;

        // keep a count of how many threads are still running
        object runCountLock = new object();
        int threadRunning = 0;

        foreach (World w in Worlds)
        {
            foreach (Trigger t in w.Triggers)
            {
                lock (runCountLock)
                {
                    threadRunning++;
                }

                ThreadPool.QueueUserWorkItem(o =>
                {
                    // [snip]: Do some work involving compiling code already in memory with CSharpCodeProvider

                    // provide some pretty feedback
                    lock (iconLock)
                    {
                        if (iconIsOut)
                            notifyIcon.Icon = Properties.Resources.Icon16in;
                        else
                            notifyIcon.Icon = Properties.Resources.Icon16out;

                        iconIsOut = !iconIsOut;
                    }

                    lock (runCountLock)
                    {
                        threadRunning--;
                    }
                });
            }
        }

        // wait for all the threads to finish up
        while (true)
        {
            lock (runCountLock)
            {
                if (threadRunning == 0)
                    break;
            }
        }

        // set the notification icon to our default icon.
        notifyIcon.Icon = Properties.Resources.Icon16;
    }
    // we're going down before we finished starting...
    // oh well, be nice about it.
    catch (ThreadAbortException) { }
}

Answer 1

Interlocked.Increment 比锁定更好，但最后的轮询循环让我害怕。 首先，如果要循环，则每次执行 Thread.Sleep(0) 来释放处理器。 其次，如果你要轮询一个变量，那么你需要确保它要么被标记为易失性，要么使用 MemoryBarrier，否则编译器可能会假设没有外部线程会更改它，因此优化掉检查，从而导致无限环形。

更好的是每个线程检查它是否达到零，如果达到零则设置一个事件。 然后您可以等待事件而不是轮询。 唯一的技巧是您希望在调度循环之前在主线程中递增一次，然后在等待事件之前递减并检查零。

编辑

如果它因为重用触发器而被破坏，那么闭包就是错误的。 尝试将 world 的值复制到循环内部的本地变量中，并将该变量用于 lambda 表达式。

Answer 2

我认为你可以做得更好。 无需锁定 threadRunning 的更改。 您可以只使用 Interlocked.Increment() 和 Interlocked.Decrement()：

        Interlocked.Increment(ref threadRunning);
        ThreadPool.QueueUserWorkItem(o =>
        {
            // [snip]: Do some work involving compiling code already in memory with CSharpCodeProvider

            // provide some pretty feedback
            lock (iconLock)
            {
                notifyIcon.Icon = (iconIsOut ? Properties.Resources.Icon16in : Properties.Resources.Icon16out);
                iconIsOut = !iconIsOut;
            }

            Interlocked.Decrement(ref threadRunning);
        });

Answer 3

线程池自动将运行线程的数量限制为最大效率的处理器数量。 每个上下文切换高达 1Mb（默认）以 4Kb 页面增量内存交换，因此，如果您使用的线程多于内核，则可能会得到无需上下文切换即可实现大量速度。