.NET Threadpool的一点认识

说到.NET Threadpool我想大家都知道，只是平时比较零散，顾现在整理一下：

一码阻塞，万码等待：ASP.NET Core 同步方法调用异步方法“死锁”的真相

.NET Threadpool starvation, and how queuing makes it worse

New and Improved CLR 4 Thread Pool Engine

所以本文主要是验证和这里这几个文章

Threadpool queue

当您调用ThreadPool.QueueUserWorkItem时，就是想象一个全局队列，其中工作项（本质上是委托）在全局队列中排队，多个线程在一个队列中选择它们。先进先出顺序。

左侧的图像显示了主程序线程，因为它创建了一个工作项; 第二个图像显示代码排队3个工作项后的全局线程池队列; 第三个图像显示了来自线程池的2个线程，它们抓取了2个工作项并执行它们。如果在这些工作项的上下文中（即来自委托中的执行代码），为CLR线程池创建了更多的工作项，它们最终会出现在全局队列中（参见右图），并且生命仍在继续。

在CLR 4中，线程池引擎已对其进行了一些改进（它在CLR的每个版本中都进行了积极的调整），并且这些改进中的一部分是在使用新的System.Threading.Tasks时可以实现的一些性能提升。创建和启动一个Task（传递一个委托），相当于在ThreadPool上调用QueueUserWorkItem。通过基于任务的API使用时可视化CLR线程池的一种方法是，除了单个全局队列之外，线程池中的每个线程都有自己的本地队列

正如通常的线程池使用一样，主程序线程可以创建将在全局队列（例如Task1和Task2）上排队的任务，并且线程将通常以FIFO方式获取这些任务。事情分歧的是，在执行任务的上下文中创建的任何新任务（例如，Task2，Task23）最终在该线程池线程的本地队列上。

因此，从图片中进一步提升，让我们假设Task2还创建了另外两个任务，例如Task4和Task5。

任务按预期结束在本地队列上，但是线程选择在完成当前任务（即Task2）时执行哪个任务？最初令人惊讶的答案是它可能是Task5，它是排队的最后一个 - 换句话说，LIFO算法可以用于本地队列。在大多数情况下，队列中最后创建的任务所需的数据在缓存中仍然很热，因此将其拉下并执行它是有意义的。显然，这意味着顺序没有承诺，但为了更好的表现，放弃了某种程度的公平。

其他工作线程完成Task1然后转到其本地队列并发现它为空; 然后它进入全局队列并发现它为空。我们不希望它闲置在那里，所以发生了一件美妙的事情：偷工作。该线程进入另一个线程的本地队列并“窃取”一个任务并执行它！这样我们就可以保持所有核心的繁忙，这有助于实现细粒度并行负载平衡目标。在上图中，注意“窃取”以FIFO方式发生，这也是出于地方原因的好处（其数据在缓存中会很冷）。此外，在许多分而治之的场景中，之前生成的任务可能会产生更多的工作（例如Task6），这些工作现在最终会在另一个线程的队列中结束，从而减少频繁的窃取。

线程池有 n+1 个队列，每个线程有自己的本地队列（n），整个线程池有一个全局队列（1）。每个线程接活（从队列中取出任务执行）的顺序是这样的：先从自己的本地队列中找活 -> 如果本地队列为空，则从全局队列中找活 -> 如果全局队列为空，则从其他线程的本地队列中抢活。

TASK

先看以下4个demo

1：如果你运行程序，你会发现它在控制台中设法显示“Ended”几次，然后就没有任何事情发生了，就像假死了

using System;
using System.Threading;
using System.Threading.Tasks;
 
namespace Starvation
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Environment.ProcessorCount);
            ThreadPool.SetMinThreads(8, 8);
            Task.Factory.StartNew( Producer,TaskCreationOptions.None);
            Console.ReadLine();
        }
        static void Producer()
        {
            while (true)
            {
                Process();
                Thread.Sleep(200);
            }
        }
        static async Task Process()
        {
            await Task.Yield();
            var tcs = new TaskCompletionSource<bool>();
            Task.Run(() =>
            {
                Thread.Sleep(1000);
                tcs.SetResult(true);
            });
            tcs.Task.Wait();
            Console.WriteLine("Ended - " + DateTime.Now.ToLongTimeString());
        }
    }
}

2：删除Task.Yield并在Producer中手动启动新任务。应用程序最初有点挣扎，直到线程池足够增长。然后我们有一个稳定的消息流，并且线程数是稳定的

using System;
using System.Threading;
using System.Threading.Tasks;
 
namespace Starvation
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Environment.ProcessorCount);
            ThreadPool.SetMinThreads(8, 8);
            Task.Factory.StartNew(  Producer,TaskCreationOptions.None);
            Console.ReadLine();
        }
 
        static void Producer()
        {
            while (true)
            {
                // Creating a new task instead of just calling Process
                // Needed to avoid blocking the loop since we removed the Task.Yield
                Task.Factory.StartNew(Process);
                Thread.Sleep(200);
            }
        }
 
        static async Task Process()
        {
            // Removed the Task.Yield
            var tcs = new TaskCompletionSource<bool>();    
            Task.Run(() =>
            {
                Thread.Sleep(1000);
                tcs.SetResult(true);
            });
            tcs.Task.Wait();
            Console.WriteLine("Ended - " + DateTime.Now.ToLongTimeString());
        }
    }
}

3：工作代码但在其自己的线程中启动Producer会怎么样，运行效果和1相似，有假死的效果，但是感觉比1 好点

using System;
using System.Threading;
using System.Threading.Tasks;
 
namespace Starvation
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Environment.ProcessorCount);
            ThreadPool.SetMinThreads(8, 8);
            Task.Factory.StartNew( Producer, TaskCreationOptions.LongRunning); // Start in a dedicated thread
            Console.ReadLine();
        }
 
        static void Producer()
        {
            while (true)
            {
                Process();
                Thread.Sleep(200);
            }
        }
 
        static async Task Process()
        {
            await Task.Yield();
            var tcs = new TaskCompletionSource<bool>();
            Task.Run(() =>
            {
                Thread.Sleep(1000);
                tcs.SetResult(true);
            });
            tcs.Task.Wait();
            Console.WriteLine("Ended - " + DateTime.Now.ToLongTimeString());
        }
    }
}

4.Producer放回线程池线程，但在启动Process任务时使用PreferFairness标志，再次遇到第一种情况：应用程序锁定，线程数无限增加。

using System;
using System.Threading;
using System.Threading.Tasks;
 
namespace Starvation
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Environment.ProcessorCount);
            ThreadPool.SetMinThreads(8, 8);
            Task.Factory.StartNew(Producer, TaskCreationOptions.None);
            Console.ReadLine();
        }
 
        static void Producer()
        {
            while (true)
            {
                Task.Factory.StartNew(Process, TaskCreationOptions.PreferFairness); // Using PreferFairness
                Thread.Sleep(200);
            }
        }
 
        static async Task Process()
        {
            var tcs = new TaskCompletionSource<bool>();
            Task.Run(() =>
            {
                Thread.Sleep(1000);
                tcs.SetResult(true);
            });
            tcs.Task.Wait();
            Console.WriteLine("Ended - " + DateTime.Now.ToLongTimeString());
        }
    }
}

线程挑选项目排队的规则很简单：

该项将被排入全局队列：
- 如果排队项目的线程不是线程池线程
- 如果它使用ThreadPool.QueueUserWorkItem / ThreadPool.UnsafeQueueUserWorkItem
- 如果它使用Task.Factory.StartNew和TaskCreationOptions.PreferFairness标志
- 如果它在默认任务调度程序上使用Task.Yield
在几乎所有其他情况下，该项将被排入线程的本地队列

每当线程池线程空闲时，它将开始查看其本地队列，并以LIFO顺序对项目进行出列。如果本地队列为空，则线程将查看全局队列并以FIFO顺序出列。如果全局队列也为空，则线程将查看其他线程的本地队列并以FIFO顺序出列（以减少与队列所有者的争用，该队列以LIFO顺序出列）。

在代码的所有变体中，Thread.Sleep（1000）在本地队列中排队，因为Process总是在线程池线程中执行。但在某些情况下，我们将Process排入全局队列，而将其他队列放入本地队列：

在代码的第一个版本中，我们使用Task.Yield，它排队到全局队列
在第二个版本中，我们使用Task.Factory.StartNew，它排队到本地队列
在第三个版本中，我们将Producer线程更改为不使用线程池，因此Task.Factory.StartNew排队到全局队列
在第四个版本中，Producer再次是一个线程池线程，但我们在将Process 排入队列时使用TaskCreationOptions.PreferFairness，因此再次使用全局队列

由于使用全局队列引起的优先级，我们添加的线程越多，我们对系统施加的压力就越大，当使用本地队列（代码的第二个版本）时，新生成的线程将从其他线程的本地队列中选择项目，因为全局队列为空。因此，新线程有助于减轻系统压力。

posted on 2018-11-06 16:31 dz45693 阅读(1965) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

dz45693