欢迎来到科站长！

HTML/XhtmlCSSJavaScriptHTML5Dreamweaver教程Frontpage教程心得技巧JavaScriptAJAX相关ASP.NETPHP编程正则表达式ThinkPHPASP编程JSP编程编程10000问CSS/HTMLMySQLMariaDBOracleMongoDBRedisMsSqlmssql2008PostgreSQLSQLite

DedeCMSPHPCMS帝国CMSWordPressDiscuzeyouCMSPbootCMS其它CMS组装电脑教程电视盒子平板电脑鼠标键盘光存储显示器显卡笔记本主板内存网站优化工具资源建站经验微信营销网站策划网络赚钱网络创业站长故事alexa域名office激活

WindowsLinuxNginxApacheIISCentOSUbuntuDebian图标素材按钮素材字体素材

ASP.NET

当前位置： 主页 > 网络编程 > ASP.NET

.NET Core 线程池(ThreadPool)底层原理源码解析

时间：2024-11-26 09:12:38|栏目：ASP.NET|点击： 次

简介

上文提到，创建线程在操作系统层面有4大无法避免的开销。因此复用线程明显是一个更优的策略，切降低了使用线程的门槛，提高程序员的下限。

.NET Core线程池日新月异,不同版本实现都有差别，在.NET 6之前，ThreadPool底层由C++承载。在之后由C#承载。本文以.NET 8.0.8为蓝本，如有出入，请参考源码.

ThreadPool结构模型图

眼见为实

https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPoolWorkQueue.cs上源码 and windbg

internal sealed partial class ThreadPoolWorkQueue
{
        internal readonly ConcurrentQueue workItems = new ConcurrentQueue();//全局队列
        internal readonly ConcurrentQueue highPriorityWorkItems = new ConcurrentQueue();//高优先级队列,比如Timer产生的定时任务
        internal readonly ConcurrentQueue lowPriorityWorkItems =
            s_prioritizationExperiment ? new ConcurrentQueue() : null!;//低优先级队列，比如回调
        internal readonly ConcurrentQueue[] _assignableWorkItemQueues =
            new ConcurrentQueue[s_assignableWorkItemQueueCount];//CPU 核心大于32个，全局队列会分裂为好几个，目的是降低CPU核心对全局队列的锁竞争
}



ThreadPool生产者模型




眼见为实


        public void Enqueue(object callback, bool forceGlobal)
        {
            Debug.Assert((callback is IThreadPoolWorkItem) ^ (callback is Task));
            if (_loggingEnabled && FrameworkEventSource.Log.IsEnabled())
                FrameworkEventSource.Log.ThreadPoolEnqueueWorkObject(callback);
#if CORECLR
            if (s_prioritizationExperiment)//lowPriorityWorkItems目前还是实验阶段，CLR代码比较偷懒，这一段代码很不优雅，没有连续性。
            {
                EnqueueForPrioritizationExperiment(callback, forceGlobal);
            }
            else
#endif
            {
                ThreadPoolWorkQueueThreadLocals? tl;
                if (!forceGlobal && (tl = ThreadPoolWorkQueueThreadLocals.threadLocals) != null)
                {
                    tl.workStealingQueue.LocalPush(callback);//如果没有特殊情况，默认加入本地队列
                }
                else
                {
                    ConcurrentQueue queue =
                        s_assignableWorkItemQueueCount > 0 && (tl = ThreadPoolWorkQueueThreadLocals.threadLocals) != null
                            ? tl.assignedGlobalWorkItemQueue//CPU>32 加入分裂的全局队列
                            : workItems;//CPU<=32 加入全局队列
                    queue.Enqueue(callback);
                }
            }
            EnsureThreadRequested();
        }

细心的朋友，会发现highPriorityWorkItems的注入判断哪里去了？目前CLR对于高优先级队列只开放给内部，比如timer/Task使用


ThreadPool消费者模型




眼见为实


public object? Dequeue(ThreadPoolWorkQueueThreadLocals tl, ref bool missedSteal)
        {
            // Check for local work items
            object? workItem = tl.workStealingQueue.LocalPop();
            if (workItem != null)
            {
                return workItem;
            }
            // Check for high-priority work items
            if (tl.isProcessingHighPriorityWorkItems)
            {
                if (highPriorityWorkItems.TryDequeue(out workItem))
                {
                    return workItem;
                }
                tl.isProcessingHighPriorityWorkItems = false;
            }
            else if (
                _mayHaveHighPriorityWorkItems != 0 &&
                Interlocked.CompareExchange(ref _mayHaveHighPriorityWorkItems, 0, 1) != 0 &&
                TryStartProcessingHighPriorityWorkItemsAndDequeue(tl, out workItem))
            {
                return workItem;
            }
            // Check for work items from the assigned global queue
            if (s_assignableWorkItemQueueCount > 0 && tl.assignedGlobalWorkItemQueue.TryDequeue(out workItem))
            {
                return workItem;
            }
            // Check for work items from the global queue
            if (workItems.TryDequeue(out workItem))
            {
                return workItem;
            }
            // Check for work items in other assignable global queues
            uint randomValue = tl.random.NextUInt32();
            if (s_assignableWorkItemQueueCount > 0)
            {
                int queueIndex = tl.queueIndex;
                int c = s_assignableWorkItemQueueCount;
                int maxIndex = c - 1;
                for (int i = (int)(randomValue % (uint)c); c > 0; i = i < maxIndex ? i + 1 : 0, c--)
                {
                    if (i != queueIndex && _assignableWorkItemQueues[i].TryDequeue(out workItem))
                    {
                        return workItem;
                    }
                }
            }
#if CORECLR
            // Check for low-priority work items
            if (s_prioritizationExperiment && lowPriorityWorkItems.TryDequeue(out workItem))
            {
                return workItem;
            }
#endif
            // Try to steal from other threads' local work items
            {
                WorkStealingQueue localWsq = tl.workStealingQueue;
                WorkStealingQueue[] queues = WorkStealingQueueList.Queues;
                int c = queues.Length;
                Debug.Assert(c > 0, "There must at least be a queue for this thread.");
                int maxIndex = c - 1;
                for (int i = (int)(randomValue % (uint)c); c > 0; i = i < maxIndex ? i + 1 : 0, c--)
                {
                    WorkStealingQueue otherQueue = queues[i];
                    if (otherQueue != localWsq && otherQueue.CanSteal)
                    {
                        workItem = otherQueue.TrySteal(ref missedSteal);
                        if (workItem != null)
                        {
                            return workItem;
                        }
                    }
                }
            }
            return null;
        }


什么是线程饥饿?


线程饥饿(Thread Starvation)是指线程长时间得不到调度(时间片),从而无法完成任务。


  • 线程被无限阻塞
    当某个线程获取锁后长期不释放，其它线程一直在等待
  • 线程优先级降低
    操作系统锁竞争中，高优先级线程，抢占低优先级线程的CPU时间
  • 线程在等待
    比如线程Wait/Result时，线程池资源不够，导致得不到执行


眼见为实


@一线码农 使用大佬的案例


https://www.jb51.net/program/3313770o1.htm


https://www.jb51.net/aspnet/3313810g7.htm


windbg sos bug依旧存在


大佬的文章中，描述sos存在bug,无法显示线程堆积情况




经实测，在.net 8中依旧存在此bug




99851个积压队列，没有显示出来


ThreadPool如何改善线程饥饿


CLR线程池使用爬山算法来动态调整线程池的大小来来改善线程饥饿的问题。本人水平有限，放出地址，有兴趣的同学可以自行研究https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.HillClimbing.cs


ThreadPool如何增加线程


在 PortableThreadPool 中有一个子类叫 GateThread，它就是专门用来增减线程的类


其底层使用一个while (true) 每隔500ms来轮询线程数量是否足够，以及一个AutoResetEvent来接收注入线程Event.如果不够就新增


《CLR vir C#》 一书中，提过一句 CLR线程池每秒最多新增1~2个线程。结论的源头就是在这里注意：是线程池注入线程每秒1~2个，不是每秒只能创建1~2个线程。OS创建线程的速度块多了。


眼见为实


https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.cs






眼见为实


        static void Main(string[] args)
        {
            for (int i = 0;i<=100000;i++)
            {
                ThreadPool.QueueUserWorkItem((x) =>
                {
                    Console.WriteLine($"当前线程Id:{Thread.CurrentThread.ManagedThreadId}");
                    Thread.Sleep(int.MaxValue);
                });
            }
            Console.ReadLine();
        }


可以观察输出，判断是不是每秒注入1~2个线程


Task


不用多说什么了吧？


Task的底层调用模型图




Task的底层实现主要取决于TaskSchedule，一般来说，除了UI线程外，默认是调度到线程池


眼见为实


Task.Run(() => { { Console.WriteLine("Test"); } });


其底层会自动调用Start()，Start()底层调用的TaskShedule.QueueTask().而作为实现类ThreadPoolTaskScheduler.QueueTask底层调用如下。




可以看到，默认情况下(除非你自己实现一个TaskShedule抽象类).Task的底层使用ThreadPool来管理。


有意思的是，对于长任务(Long Task)，直接是用一个单独的后台线程来管理，完全不参与调度。


Task对线程池的优化


既然Task的底层是使用ThreadPool,而线程池注入速度是比较慢的。Task作为线程池的高度封装，有没有优化呢？答案是Yes当使用Task.Result时，底层会调用InternalWaitCore(),如果Task还未完成,会调用ThreadPool.NotifyThreadBlocked()来通知ThreadPool当前线程已经被阻塞，必须马上注入一个新线程来代替被阻塞的线程。相对每500ms来轮询注入线程，该方式采用事件驱动，注入线程池的速度会更快。


眼见为实


  static void Main(string[] args)
        {
            var client = new HttpClient();
            for(int i = 0; i < 100000; i++)
            {
                ThreadPool.QueueUserWorkItem(x =>
                {
                    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff")} -> {x}: 这是耗时任务");
                    try
                    {
                        var content = client.GetStringAsync("https://youtube.com").Result;
                        Console.WriteLine(content);
                    }
                    catch (Exception)
                    {
                        throw;
                    }
                });
            }
            Console.ReadLine();
        }






其底层通过AutoResetEvent来触发注入线程的Event消息


结论


多用Task，它更完善。对线程池优化更好。没有不使用Task的理由


到此这篇关于.NET Core 线程池(ThreadPool)底层原理浅谈的文章就介绍到这了,更多相关.NET Core 线程池ThreadPool内容请搜索科站长以前的文章或继续浏览下面的相关文章希望大家以后多多支持科站长！

      
      

    
    
    

      
   上一篇：.NET 9 中 LINQ 新增功能实现过程   

      
栏    目：ASP.NET

      
   下一篇：.NET 某券商论坛系统卡死问题分析   

      
本文标题：.NET Core 线程池(ThreadPool)底层原理源码解析

      
本文地址：https://www.fushidao.cc/wangluobiancheng/3290.html

      
    

    
更多ASP.NET

    

    

      

        
您可能感兴趣的文章

      

      
    

    
  
  
     

        

        

      

        
阅读排行

         
      

      
    

    

      

        
推荐教程

         
      

      
    

  




  
广告投放 | 联系我们 | 版权申明

  
申明：本站所有的文章、图片、评论等，均由网友发表或上传并维护或收集自网络，属个人行为，与本站立场无关。
 
如果侵犯了您的权利，请与我们联系，我们将在24小时内进行处理、任何非本站因素导致的法律后果，本站均不负任何责任。
  
联系QQ：257218569 | 邮箱：257218569@qq.com

  
Copyright © 2018-2025 科站长 版权所有冀ICP备14023439号