◆ GateThreadStart()

static void System.Threading.PortableThreadPool.GateThread.GateThreadStart ( )
inlinestaticprivate
Definition at line 156 of file PortableThreadPool.cs.
        {
            bool booleanConfig = AppContextConfigHelper.GetBooleanConfig("System.Threading.ThreadPool.DisableStarvationDetection", defaultValue: false);
            bool booleanConfig2 = AppContextConfigHelper.GetBooleanConfig("System.Threading.ThreadPool.DebugBreakOnWorkerStarvation", defaultValue: false);
            CpuUtilizationReader cpuUtilizationReader = default(CpuUtilizationReader);
            _ = cpuUtilizationReader.CurrentUtilization;
            PortableThreadPool threadPoolInstance = ThreadPoolInstance;
            LowLevelLock threadAdjustmentLock = threadPoolInstance._threadAdjustmentLock;
            DelayHelper delayHelper = default(DelayHelper);
            if (BlockingConfig.IsCooperativeBlockingEnabled)
            {
                threadPoolInstance.OnGen2GCCallback();
                Gen2GcCallback.Register(threadPoolInstance.OnGen2GCCallback);
            }
            while (true)
            {
                RunGateThreadEvent.WaitOne();
                int tickCount = Environment.TickCount;
                delayHelper.SetGateActivitiesTime(tickCount);
                while (true)
                {
                    bool wasSignaledToWake = DelayEvent.WaitOne((int)delayHelper.GetNextDelay(tickCount));
                    tickCount = Environment.TickCount;
                    PendingBlockingAdjustment pendingBlockingAdjustment = threadPoolInstance._pendingBlockingAdjustment;
                    if (pendingBlockingAdjustment == PendingBlockingAdjustment.None)
                    {
                        delayHelper.ClearBlockingAdjustmentDelay();
                    }
                    else
                    {
                        bool flag = false;
                        if (delayHelper.HasBlockingAdjustmentDelay)
                        {
                            flag = delayHelper.HasBlockingAdjustmentDelayElapsed(tickCount, wasSignaledToWake);
                            if (pendingBlockingAdjustment == PendingBlockingAdjustment.WithDelayIfNecessary && !flag)
                            {
                                goto IL_00ee;
                            }
                        }
                        uint num = threadPoolInstance.PerformBlockingAdjustment(flag);
                        if (num == 0)
                        {
                            delayHelper.ClearBlockingAdjustmentDelay();
                        }
                        else
                        {
                            delayHelper.SetBlockingAdjustmentTimeAndDelay(tickCount, num);
                        }
                    }
                    goto IL_00ee;
                    IL_00ee:
                    if (!delayHelper.ShouldPerformGateActivities(tickCount, wasSignaledToWake))
                    {
                        continue;
                    }
                    if (ThreadPool.EnableWorkerTracking && NativeRuntimeEventSource.Log.IsEnabled())
                    {
                        NativeRuntimeEventSource.Log.ThreadPoolWorkingThreadCount((uint)threadPoolInstance.GetAndResetHighWatermarkCountOfThreadsProcessingUserCallbacks(), 0);
                    }
                    bool flag2 = ThreadPool.PerformRuntimeSpecificGateActivities(threadPoolInstance._cpuUtilization = cpuUtilizationReader.CurrentUtilization);
                    if (!booleanConfig && threadPoolInstance._pendingBlockingAdjustment == PendingBlockingAdjustment.None && threadPoolInstance._separated.numRequestedWorkers > 0 && SufficientDelaySinceLastDequeue(threadPoolInstance))
                    {
                        bool flag3 = false;
                        threadAdjustmentLock.Acquire();
                        try
                        {
                            ThreadCounts threadCounts = threadPoolInstance._separated.counts;
                            while (threadCounts.NumProcessingWork < threadPoolInstance._maxThreads && threadCounts.NumProcessingWork >= threadCounts.NumThreadsGoal)
                            {
                                if (booleanConfig2)
                                {
                                    Debugger.Break();
                                }
                                ThreadCounts newCounts = threadCounts;
                                short newThreadCount = (newCounts.NumThreadsGoal = (short)(threadCounts.NumProcessingWork + 1));
                                ThreadCounts threadCounts2 = threadPoolInstance._separated.counts.InterlockedCompareExchange(newCounts, threadCounts);
                                if (threadCounts2 == threadCounts)
                                {
                                    HillClimbing.ThreadPoolHillClimber.ForceChange(newThreadCount, HillClimbing.StateOrTransition.Starvation);
                                    flag3 = true;
                                    break;
                                }
                                threadCounts = threadCounts2;
                            }
                        }
                        finally
                        {
                            threadAdjustmentLock.Release();
                        }
                        if (flag3)
                        {
                            WorkerThread.MaybeAddWorkingWorker(threadPoolInstance);
                        }
                    }
                    if (!flag2 && threadPoolInstance._separated.numRequestedWorkers <= 0 && threadPoolInstance._pendingBlockingAdjustment == PendingBlockingAdjustment.None && Interlocked.Decrement(ref threadPoolInstance._separated.gateThreadRunningState) <= GetRunningStateForNumRuns(0))
                    {
                        break;
                    }
                }
            }
        }
Referenced by System.Threading.PortableThreadPool.GateThread.CreateGateThread().