private void ProcessQueuedItems() { _threadPool = this; try { bool flag = false; while (!this._shutdown) { this._workerThreads[Thread.CurrentThread] = DateTime.Now; WorkItem workItem = this.Dequeue(); this._workerThreads[Thread.CurrentThread] = DateTime.Now; if ((workItem == null) && (this._workerThreads.Count > this._threadPoolStartInfo.MinWorkerThreads)) { lock (this._workerThreads.SyncRoot) { if (this._workerThreads.Count > this._threadPoolStartInfo.MinWorkerThreads) { if (this._workerThreads.Contains(Thread.CurrentThread)) { this._workerThreads.Remove(Thread.CurrentThread); } return; } } } if (workItem != null) { int num; try { flag = false; if (!workItem.StartingWorkItem()) { continue; } num = Interlocked.Increment(ref this._inUseWorkerThreads); flag = true; _currentWorkItem = workItem; this.ExecuteWorkItem(workItem); } catch (Exception) { } finally { if (workItem != null) { workItem.DisposeState(); } _currentWorkItem = null; if (flag) { num = Interlocked.Decrement(ref this._inUseWorkerThreads); } this.DecrementWorkItemsCount(); } } } } catch (ThreadAbortException) { Thread.ResetAbort(); } catch (Exception) { } finally { if (this._workerThreads.Contains(Thread.CurrentThread)) { this._workerThreads.Remove(Thread.CurrentThread); } } }
/// <summary> /// A worker thread method that processes work items from the work items queue. /// </summary> private void ProcessQueuedItems() { // Initialize the _threadPool variable _threadPool = this; try { bool inUseWorkerThreadsWasIncremented = false; // Process until shutdown. while(!_shutdown) { // Update the last time this thread was alive. _workerThreads[Thread.CurrentThread] = DateTime.Now; // Wait for a work item, shutdown, or timeout WorkItem workItem = Dequeue(); // Update the last time this thread was alive. _workerThreads[Thread.CurrentThread] = DateTime.Now; // On timeout or shut down. if (workItem == null) { // Double lock for quit. if (_workerThreads.Count > _threadPoolStartInfo.MinWorkerThreads) { lock(_workerThreads.SyncRoot) { if (_workerThreads.Count > _threadPoolStartInfo.MinWorkerThreads) { //Quit if (_workerThreads.Contains(Thread.CurrentThread)) { _workerThreads.Remove(Thread.CurrentThread); } break; } } } } // If we didn't quit then skip to the next iteration. if (workItem == null) continue; try { // Initialize the value to false inUseWorkerThreadsWasIncremented = false; // Change the state of the work item to 'in progress' if possible. // The cancel mechanism doesn't delete items from the queue, it marks the work item as canceled, // and when the work item is dequeued, we just skip it. if (!workItem.StartingWorkItem()) continue; // Execute the callback. Make sure to accurately record how many callbacks are currently executing. int inUseWorkerThreads = Interlocked.Increment(ref _inUseWorkerThreads); // Mark that the _inUseWorkerThreads incremented, so in the finally{} statement we will decrement it correctly. inUseWorkerThreadsWasIncremented = true; // Set the _currentWorkItem to the current work item _currentWorkItem = workItem; ExecuteWorkItem(workItem); } catch(Exception) { // Do nothing } finally { if (workItem != null) workItem.DisposeState(); _currentWorkItem = null; // Decrement the _inUseWorkerThreads only if we had incremented it. if (inUseWorkerThreadsWasIncremented) { int inUseWorkerThreads = Interlocked.Decrement(ref _inUseWorkerThreads); } // Decrement the number of work items here so the idle ManualResetEvent won't fluctuate. DecrementWorkItemsCount(); } } } catch(ThreadAbortException) { // Handle the abort exception gracfully. Thread.ResetAbort(); } catch(Exception) { } finally { if (_workerThreads.Contains(Thread.CurrentThread)) _workerThreads.Remove(Thread.CurrentThread); } }
public SchedulingService() { _paused = false; _halted = false; _threadPool = new ThreadPoolEx(ThreadPoolEx.DefaultIdleTimeout, 10); _thread = new Thread(new ThreadStart(Run)); _thread.Start(); }
/// <summary> /// A worker thread method that processes work items from the work items queue. /// </summary> private void ProcessQueuedItems() { // Initialize the _threadPool variable _threadPool = this; try { bool inUseWorkerThreadsWasIncremented = false; // Process until shutdown. while (!_shutdown) { // Update the last time this thread was alive. _workerThreads[Thread.CurrentThread] = DateTime.Now; // Wait for a work item, shutdown, or timeout WorkItem workItem = Dequeue(); // Update the last time this thread was alive. _workerThreads[Thread.CurrentThread] = DateTime.Now; // On timeout or shut down. if (workItem == null) { // Double lock for quit. if (_workerThreads.Count > _threadPoolStartInfo.MinWorkerThreads) { lock (_workerThreads.SyncRoot) { if (_workerThreads.Count > _threadPoolStartInfo.MinWorkerThreads) { //Quit if (_workerThreads.Contains(Thread.CurrentThread)) { _workerThreads.Remove(Thread.CurrentThread); } break; } } } } // If we didn't quit then skip to the next iteration. if (workItem == null) { continue; } try { // Initialize the value to false inUseWorkerThreadsWasIncremented = false; // Change the state of the work item to 'in progress' if possible. // The cancel mechanism doesn't delete items from the queue, it marks the work item as canceled, // and when the work item is dequeued, we just skip it. if (!workItem.StartingWorkItem()) { continue; } // Execute the callback. Make sure to accurately record how many callbacks are currently executing. int inUseWorkerThreads = Interlocked.Increment(ref _inUseWorkerThreads); // Mark that the _inUseWorkerThreads incremented, so in the finally{} statement we will decrement it correctly. inUseWorkerThreadsWasIncremented = true; // Set the _currentWorkItem to the current work item _currentWorkItem = workItem; ExecuteWorkItem(workItem); } catch (Exception) { // Do nothing } finally { if (workItem != null) { workItem.DisposeState(); } _currentWorkItem = null; // Decrement the _inUseWorkerThreads only if we had incremented it. if (inUseWorkerThreadsWasIncremented) { int inUseWorkerThreads = Interlocked.Decrement(ref _inUseWorkerThreads); } // Decrement the number of work items here so the idle ManualResetEvent won't fluctuate. DecrementWorkItemsCount(); } } } catch (ThreadAbortException) { #if !NET5_0_OR_GREATER // Handle the abort exception gracfully. Thread.ResetAbort(); #endif } catch (Exception) { } finally { if (_workerThreads.Contains(Thread.CurrentThread)) { _workerThreads.Remove(Thread.CurrentThread); } } }