ThreadPool Blocking Mitigation

src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs

@@ -161,7 +161,7 @@ public override int GetHashCode()
                 return GetType().GetHashCode();
         }
 
-        protected virtual MethodInfo GetMethodImpl()
+        protected internal virtual MethodInfo GetMethodImpl()
         {
             if ((_methodBase == null) || !(_methodBase is MethodInfo))
             {

src/coreclr/System.Private.CoreLib/src/System/MulticastDelegate.cs

@@ -523,7 +523,7 @@ public sealed override int GetHashCode()
             return base.GetTarget();
         }
 
-        protected override MethodInfo GetMethodImpl()
+        protected internal override MethodInfo GetMethodImpl()
         {
             if (_invocationCount != (IntPtr)0 && _invocationList != null)
             {

src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

@@ -1013,6 +1013,8 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadInterruptedException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadLocal.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadPool.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadPoolBlockingQueue.AnyOS.cs" Condition="'$(TargetsBrowser)' != 'true'" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadPoolBlockingQueue.Browser.cs" Condition="'$(TargetsBrowser)' == 'true'" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadPriority.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadStart.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadStartException.cs" />

src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs

@@ -2851,6 +2851,11 @@ private bool SpinThenBlockingWait(int millisecondsTimeout, CancellationToken can
             bool returnValue = SpinWait(millisecondsTimeout);
             if (!returnValue)
             {
+                if (Thread.CurrentThread.IsThreadPoolThread)
+                {
+                    ThreadPool.RecordBlockingCallsite();
+                }
+
                 var mres = new SetOnInvokeMres();
                 try
                 {

src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPool.cs

@@ -514,6 +514,13 @@ public void Enqueue(object callback, bool forceGlobal)
             if (loggingEnabled && FrameworkEventSource.Log.IsEnabled())
                 FrameworkEventSource.Log.ThreadPoolEnqueueWorkObject(callback);
 
+            if (ThreadPoolBlockingQueue.IsEnabled &&
+                ThreadPoolBlockingQueue.RequiresMitigation(callback))
+            {
+                callback = ThreadPoolBlockingQueue.Enqueue(callback);
+                forceGlobal = true;
+            }
+
             ThreadPoolWorkQueueThreadLocals? tl = null;
             if (!forceGlobal)
                 tl = ThreadPoolWorkQueueThreadLocals.threadLocals;
@@ -679,47 +686,15 @@ internal static bool Dispatch()
                         }
                     }
 
-                    if (workQueue.loggingEnabled && FrameworkEventSource.Log.IsEnabled())
-                        FrameworkEventSource.Log.ThreadPoolDequeueWorkObject(workItem);
-
-                    //
-                    // If we found work, there may be more work.  Ask for another thread so that the other work can be processed
-                    // in parallel.  Note that this will only ask for a max of #procs threads, so it's safe to call it for every dequeue.
-                    //
-                    workQueue.EnsureThreadRequested();
-
-                    //
-                    // Execute the workitem outside of any finally blocks, so that it can be aborted if needed.
-                    //
-#pragma warning disable CS0162 // Unreachable code detected. EnableWorkerTracking may be a constant in some runtimes.
-                    if (ThreadPool.EnableWorkerTracking)
-                    {
-                        DispatchWorkItemWithWorkerTracking(workItem, currentThread);
-                    }
-                    else if (workItem is Task task)
-                    {
-                        // Check for Task first as it's currently faster to type check
-                        // for Task and then Unsafe.As for the interface, rather than
-                        // vice versa, in particular when the object implements a bunch
-                        // of interfaces.
-                        task.ExecuteFromThreadPool(currentThread);
-                    }
-                    else
-                    {
-                        Debug.Assert(workItem is IThreadPoolWorkItem);
-                        Unsafe.As<IThreadPoolWorkItem>(workItem).Execute();
-                    }
-#pragma warning restore CS0162
+                    workQueue.RunWorkItem(currentThread, workItem);
 
                     // Release refs
                     workItem = null;
 
-                    // Return to clean ExecutionContext and SynchronizationContext. This may call user code (AsyncLocal value
-                    // change notifications).
-                    ExecutionContext.ResetThreadPoolThread(currentThread);
-
-                    // Reset thread state after all user code for the work item has completed
-                    currentThread.ResetThreadPoolThread();
+                    if (ThreadPoolBlockingQueue.IsEnabled)
+                    {
+                        ThreadPoolBlockingQueue.ClearRegistration();
+                    }
 
                     //
                     // Notify the VM that we executed this workitem.  This is also our opportunity to ask whether Hill Climbing wants
@@ -770,8 +745,62 @@ internal static bool Dispatch()
             }
         }
 
+        internal void RunWorkItem(Thread currentThread, object workItem)
+        {
+            if (loggingEnabled && FrameworkEventSource.Log.IsEnabled())
+                FrameworkEventSource.Log.ThreadPoolDequeueWorkObject(workItem);
+
+            //
+            // If we found work, there may be more work.  Ask for another thread so that the other work can be processed
+            // in parallel.  Note that this will only ask for a max of #procs threads, so it's safe to call it for every dequeue.
+            //
+            EnsureThreadRequested();
+
+            if (ThreadPoolBlockingQueue.IsEnabled)
+            {
+                if (ThreadPoolBlockingQueue.RequiresMitigation(workItem))
+                {
+                    workItem = ThreadPoolBlockingQueue.Enqueue(workItem);
+                }
+                else
+                {
+                    ThreadPoolBlockingQueue.RegisterForBlockingDetection(workItem);
+                }
+            }
+
+            //
+            // Execute the workitem outside of any finally blocks, so that it can be aborted if needed.
+            //
+#pragma warning disable CS0162 // Unreachable code detected. EnableWorkerTracking may be a constant in some runtimes.
+            if (ThreadPool.EnableWorkerTracking)
+            {
+                DispatchWorkItemWithWorkerTracking(workItem, currentThread);
+            }
+            else if (workItem is Task task)
+            {
+                // Check for Task first as it's currently faster to type check
+                // for Task and then Unsafe.As for the interface, rather than
+                // vice versa, in particular when the object implements a bunch
+                // of interfaces.
+                task.ExecuteFromThreadPool(currentThread);
+            }
+            else
+            {
+                Debug.Assert(workItem is IThreadPoolWorkItem);
+                Unsafe.As<IThreadPoolWorkItem>(workItem).Execute();
+            }
+#pragma warning restore CS0162
+
+            // Return to clean ExecutionContext and SynchronizationContext. This may call user code (AsyncLocal value
+            // change notifications).
+            ExecutionContext.ResetThreadPoolThread(currentThread);
+
+            // Reset thread state after all user code for the work item has completed
+            currentThread.ResetThreadPoolThread();
+        }
+
         [MethodImpl(MethodImplOptions.NoInlining)]
-        private static void DispatchWorkItemWithWorkerTracking(object workItem, Thread currentThread)
+        internal static void DispatchWorkItemWithWorkerTracking(object workItem, Thread currentThread)
         {
             Debug.Assert(ThreadPool.EnableWorkerTracking);
             Debug.Assert(currentThread == Thread.CurrentThread);
@@ -846,6 +875,8 @@ public ThreadPoolWorkQueueThreadLocals(ThreadPoolWorkQueue tpq)
 
     internal abstract class QueueUserWorkItemCallbackBase : IThreadPoolWorkItem
     {
+        public abstract Delegate? Callback { get; }
+
 #if DEBUG
         private int executed;
 
@@ -892,6 +923,8 @@ internal QueueUserWorkItemCallback(WaitCallback callback, object? state, Executi
             _context = context;
         }
 
+        public override Delegate? Callback => _callback;
+
         public override void Execute()
         {
             base.Execute();
@@ -915,6 +948,8 @@ internal QueueUserWorkItemCallback(Action<TState> callback, TState state, Execut
             _context = context;
         }
 
+        public override Delegate? Callback => _callback;
+
         public override void Execute()
         {
             base.Execute();
@@ -940,6 +975,8 @@ internal QueueUserWorkItemCallbackDefaultContext(WaitCallback callback, object?
             _state = state;
         }
 
+        public override Delegate? Callback => _callback;
+
         public override void Execute()
         {
             ExecutionContext.CheckThreadPoolAndContextsAreDefault();
@@ -968,6 +1005,8 @@ internal QueueUserWorkItemCallbackDefaultContext(Action<TState> callback, TState
             _state = state;
         }
 
+        public override Delegate? Callback => _callback;
+
         public override void Execute()
         {
             ExecutionContext.CheckThreadPoolAndContextsAreDefault();