ToB企服应用市场:ToB评测及商务社交产业平台

标题: 聊一聊 C#线程池 的线程动态注入 (下) [打印本页]
作者: 耶耶耶耶耶    时间: 2024-12-25 12:20
标题: 聊一聊 C#线程池 的线程动态注入 (下)
一：背景

1. 讲故事

前面二篇我们聊到了 Thread.Sleep 和 Task.Result 场景下的线程注入逻辑，在线程饥饿的情况下注入速度都不是很理想，那怎么办呢？有没有更快的注入速度，这篇作为 动态注入 的终结篇，我个人总结如下两种方法，当然可能有更多的路子，知道的朋侪可以在下面留言。
二：提高注入速度的两种方法

1. 低落GateThread的延迟时间

上一篇跟大家聊过 Result 默认情况下GateThread每秒会注入4个，底层逻辑是由 Blocking.MaxDelayMs=250ms 变量控制的，言外之意就是能不能减少这个变量的值呢？当然可以的，这里我们改成 100ms，参考代码如下：
  1.         static void Main(string[] args)
  2.         {
  3.             AppContext.SetData("System.Threading.ThreadPool.Blocking.MaxDelayMs", 100);
  5.             for (int i = 0; i < 10000; i++)
  6.             {
  7.                 ThreadPool.QueueUserWorkItem((idx) =>
  8.                 {
  9.                     Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff")} -> {idx}: 这是耗时任务");
  11.                     try
  12.                     {
  13.                         var client = new HttpClient();
  14.                         var content = client.GetStringAsync("https://youtube.com").Result;
  15.                         Console.WriteLine(content.Length);
  16.                     }
  17.                     catch (Exception ex)
  18.                     {
  19.                         Console.WriteLine(ex.Message);
  20.                     }
  21.                 }, i);
  22.             }
  24.             Console.ReadLine();
  25.         }
复制代码
现在我们照旧用上一篇的方法在如下三个方法 HasBlockingAdjustmentDelayElapsed,PerformBlockingAdjustment,CreateWorkerThread  上埋日记断点，埋好之后运行程序观察。

从卦中的输出结果看，注入速度明显快了很多，判断阈值也从 250ms 变成了 100ms，每秒能注入7~8个线程，所以这是一个简单粗暴的提速方法。
2. 提高 MinThreads 的阈值

看过上两篇的朋侪应该知道，我用过 喷涌而出 四个字来形容前 12个线程，这里的12是因为我的机器是 12 核，言外之意就是为什么要设置12呢？我能不能给它提升到 120，1200甚至更高的 12000 呢？如许线程的注入速度不是更快吗？有了这个想法赶紧上一段代码，参考如下：
  1.         static void Main(string[] args)
  2.         {
  3.             ThreadPool.SetMinThreads(10000, 10);
  5.             for (int i = 0; i < 10000; i++)
  6.             {
  7.                 ThreadPool.QueueUserWorkItem((idx) =>
  8.                 {
  9.                     Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff")} -> {idx}: 这是耗时任务");
  11.                     Thread.Sleep(int.MaxValue);
  12.                 }, i);
  13.             }
  15.             Console.ReadLine();
  16.         }
复制代码

从卦中看，直接秒了这个 10000 个任务，但不要忘了你的程序此时有1w个线程，如果是32bit程序大概率因为假造地址不足直接崩了，如果是 64bit 可能也会导致非常可观的内存占用。
有些人可能对底层逻辑感兴趣，我特意花了点时间绘了一张图来形貌底层的运转逻辑。


之所以能快速的产生新线程，核心判断条件是 numProcessingWork  (int)this._maxThreads)            {                return false;            }            if (ioCompletionThreads > (int)this._legacy_maxIOCompletionThreads)            {                return false;            }        }[/code]从卦中代码可以看到 ioCompletionThreads 默认最大值为 1000，如果你设置的值大于 1000 的话，那前面的 workerThreads 即是白设置了。。。这就很无语了。。。 如果参数有误，你完全可以抛出一个异常来告诉我，，，而不是偷偷的掩埋错误信息，导致程序出现了我意想不到的行为。。。
为了凑篇幅，我再说一个有意思的参数 DebugBreakOnWorkerStarvation，它可以用来捕获 线程饥饿 的第一现场，底层逻辑是C#团队在代码里埋了一个钩子，参考如下：
  1.         public class PortableThreadPool
  2.         {
  3.             private short _minThreads;
  4.             private short _maxThreads;
  5.             private short _legacy_maxIOCompletionThreads;
  6.             private const short DefaultMaxWorkerThreadCount = MaxPossibleThreadCount;
  7.             private const short MaxPossibleThreadCount = short.MaxValue;
  9.             private PortableThreadPool()
  10.             {
  11.                 _minThreads = HasForcedMinThreads ? ForcedMinWorkerThreads : (short)Environment.ProcessorCount;
  12.                 _maxThreads = HasForcedMaxThreads ? ForcedMaxWorkerThreads : DefaultMaxWorkerThreadCount;
  13.                 _legacy_maxIOCompletionThreads = 1000;
  14.             }
  15.         }
  17.         public bool SetMinThreads(int workerThreads, int ioCompletionThreads)
  18.         {
  19.             if (workerThreads < 0 || ioCompletionThreads < 0)
  20.             {
  21.                 return false;
  22.             }
  23.             bool flag = false;
  24.             bool flag2 = false;
  25.             this._threadAdjustmentLock.Acquire();
  26.             if (workerThreads > (int)this._maxThreads)
  27.             {
  28.                 return false;
  29.             }
  30.             if (ioCompletionThreads > (int)this._legacy_maxIOCompletionThreads)
  31.             {
  32.                 return false;
  33.             }
  34.         }
复制代码
这个 Debugger.Break(); 发出的 int 3 信号，我们可以用 VS,DnSpy,WinDbg 如许的调试器去捕获，参考代码如下：
  1.         private static void GateThreadStart()
  2.         {
  3.             bool debuggerBreakOnWorkStarvation = AppContextConfigHelper.GetBooleanConfig("System.Threading.ThreadPool.DebugBreakOnWorkerStarvation", false);
  5.             while (counts.NumProcessingWork < threadPoolInstance._maxThreads && counts.NumProcessingWork >= counts.NumThreadsGoal)
  6.             {
  7.                 if (debuggerBreakOnWorkStarvation)
  8.                 {
  9.                     Debugger.Break();
  10.                 }
  11.             }
  12.         }
复制代码

三：总结

我们聊到了两种提升线程注入的方法，尤其是第二种让人意难平，面对上游洪水猛兽般的对线程池举行DDOS攻击，下游的线程不顾一切，倾家荡产的去承接，这是一种明知不可为而为之的悲壮之举。


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4