public static void Reset() { lock (_poolLock) { try { foreach (object current in _waitingCallbacks) { WaitingCallback waitingCallback = (WaitingCallback)current; if (waitingCallback.State is IDisposable) { ((IDisposable)waitingCallback.State).Dispose(); } } } catch { } try { foreach (Thread thread in _workerThreads) { if (thread != null) { thread.Abort("reset"); } } } catch { } Initialize(); } }
/// <summary>Empties the work queue of any queued work items.</summary> public static void EmptyQueue() { lock (_waitingCallbacks.SyncRoot) { try { // Try to dispose of all remaining state foreach (object obj in _waitingCallbacks) { WaitingCallback callback = (WaitingCallback)obj; if (callback.State is IDisposable) { ((IDisposable)callback.State).Dispose(); } } } catch { // Make sure an error isn't thrown. } // Clear all waiting items and reset the number of worker threads currently needed // to be 0 (there is nothing for threads to do) _waitingCallbacks.Clear(); _workerThreadNeeded.Reset(0); } }
/// <summary>Empties the work queue of any queued work items. Resets all threads in the pool.</summary> public static void Reset() { lock (_poolLock) { // Cleanup any waiting callbacks try { // Try to dispose of all remaining state foreach (object obj in _waitingCallbacks) { WaitingCallback callback = (WaitingCallback)obj; if (callback.State is IDisposable) { ((IDisposable)callback.State).Dispose(); } } } catch { } // Shutdown all existing threads try { foreach (Thread thread in _workerThreads) { if (thread != null) { thread.Abort("reset"); } } } catch { } // Reinitialize the pool (create new threads, etc.) Initialize(); } }
/// <summary> /// A thread worker function that processes items from the work queue. /// </summary> private static void ProcessQueuedItems() { // Process indefinitely while (true) { _workerThreadNeeded.WaitOne(); // Get the next item in the queue. If there is nothing there, go to sleep // for a while until we're woken up when a callback is waiting. WaitingCallback callback = null; // Try to get the next callback available. We need to lock on the // queue in order to make our count check and retrieval atomic. lock (_poolLock) { if (_waitingCallbacks.Count > 0) { try { callback = (WaitingCallback)_waitingCallbacks.Dequeue(); } catch { } // make sure not to fail here } } if (callback != null) { // We now have a callback. Execute it. Make sure to accurately // record how many callbacks are currently executing. try { Interlocked.Increment(ref _inUseThreads); callback.Callback(callback.State); } #if NET1 catch (Exception exc) { //暂时注释下面的代码 try { UnhandledExceptionEventHandler handler = UnhandledException; if (handler != null) { handler(typeof(ManagedThreadPool), new UnhandledExceptionEventArgs(exc, false)); } } catch {} } #else catch { ; } #endif finally { Interlocked.Decrement(ref _inUseThreads); } } } }
/// <summary>Queues a user work item to the thread pool.</summary> /// <param name="callback"> /// A WaitCallback representing the delegate to invoke when the thread in the /// thread pool picks up the work item. /// </param> /// <param name="state"> /// The object that is passed to the delegate when serviced from the thread pool. /// </param> /// <param name="priority">The priority for this callback.</param> public static void QueueUserWorkItem(WaitCallback callback, object state, int priority) { // Create a waiting callback that contains the delegate and its state. // At it to the processing queue, and signal that data is waiting. WaitingCallback waiting = new WaitingCallback(callback, state); lock (_waitingCallbacks.SyncRoot) { _waitingCallbacks.Enqueue(priority, waiting); } _workerThreadNeeded.AddOne(); }
/// <summary>将用户工作项排入线程池.</summary> /// <param name="callback"> /// WaitCallback表示在线程中调用时委托的委托 ///线程池选取工作项。 /// </param> /// <param name="state"> /// 从线程池提供服务时传递给委托的对象. /// </param> public static void QueueUserWorkItem(WaitCallback callback, object state) { //创建一个包含委托及其状态的等待回调。 //在它处理队列,并发出数据正在等待的信号。 WaitingCallback waiting = new WaitingCallback(callback, state); lock (_poolLock) { _waitingCallbacks.Enqueue(waiting); } _workerThreadNeeded.AddOne(); }
public static void QueueUserWorkItem(WaitCallback callback, object state) { WaitingCallback obj = new WaitingCallback(callback, state); lock (_poolLock) { _waitingCallbacks.Enqueue(obj); } _workerThreadNeeded.AddOne(); }
/// <summary> /// Queues a user work item to the thread pool. /// </summary> /// <param name="callback"> /// A WaitCallback representing the delegate to invoke when the thread in the /// thread pool picks up the work item. /// </param> /// <param name="state"> /// The object that is passed to the delegate when serviced from the thread pool. /// </param> public void QueueUserWorkItem(WaitCallback callback, object state) { if (!shutdown) { WaitingCallback waiting = new WaitingCallback(callback, state); countdownThreads.AddCount(1); _waitingCallbacks.Enqueue(waiting); _workerThreadNeeded.AddOne(); } }
/// <summary>Queues a user work item to the thread pool.</summary> /// <param name="callback"> /// A WaitCallback representing the delegate to invoke when the thread in the /// thread pool picks up the work item. /// </param> /// <param name="state"> /// The object that is passed to the delegate when serviced from the thread pool. /// </param> public static void QueueUserWorkItem(WaitCallback callback, object state) { // Create a waiting callback that contains the delegate and its state. // At it to the processing queue, and signal that data is waiting. var waiting = new WaitingCallback(callback, state); lock (PoolLock) { _waitingCallbacks.Enqueue(waiting); } _workerThreadNeeded.AddOne(); }
/// <summary>Event raised when there is an exception on a threadpool thread.</summary> /// <summary>A thread worker function that processes items from the work queue.</summary> private static void ProcessQueuedItems() { // Process indefinitely while (true) { //判断有无资源操作,如果有则执行【即从队列中取】,如没有则将当前线程置为等待。注意当前信息量中count数量与_waitingCallbacks队列长度相同。 //通过QueueUserWorkItem的_workerThreadNeeded.AddOne();代码行来告之在当前线程池中处于wait的线程列表中找出一个线程来执行_waitingCallbacks列队中的任务(Dequeue). //如果进程池中所有线程均为执行状态时,则系统还运行QueueUserWorkItem()函数则可视其仅将任务放入队列即可,因为此处的while(true)会不断从队列中获取任务执行。 _workerThreadNeeded.WaitOne(); // Get the next item in the queue. If there is nothing there, go to sleep // for a while until we're woken up when a callback is waiting. WaitingCallback callback = null; // Try to get the next callback available. We need to lock on the // queue in order to make our count check and retrieval atomic. lock (PoolLock) { if (_waitingCallbacks.Count > 0) { try { callback = (WaitingCallback)_waitingCallbacks.Dequeue(); } catch { // ignored } // make sure not to fail here } } if (callback != null) { // We now have a callback. Execute it. Make sure to accurately // record how many callbacks are currently executing. try { Interlocked.Increment(ref _inUseThreads); callback.Callback(callback.State); } catch { // ignored } finally { Interlocked.Decrement(ref _inUseThreads); } } } }
/// <summary>A thread worker function that processes items from the work queue.</summary> private static void ProcessQueuedItems() { // Process indefinitely while (!Project.goingDown) { // Get the next item in the queue. If there is nothing there, go to sleep // for a while until we're woken up when a callback is waiting. WaitingCallback callback = null; while (callback == null) { // Try to get the next callback available. We need to lock on the // queue in order to make our count check and retrieval atomic. lock (_waitingCallbacks.SyncRoot) { if (_waitingCallbacks.Count > 0) { //try { callback = (WaitingCallback)_waitingCallbacks.Dequeue(); } try { callback = (WaitingCallback)_waitingCallbacks.Pop(); } catch {} // make sure not to fail here } } if (Project.goingDown) { return; } // If we can't get one, go to sleep. if (callback == null) { _workerThreadNeeded.WaitOne(); } } // We now have a callback. Execute it. Make sure to accurately // record how many callbacks are currently executing. try { Interlocked.Increment(ref _inUseThreads); callback.Callback(callback.State); } catch { // Make sure we don't throw here. Errors are not our problem. } finally { Interlocked.Decrement(ref _inUseThreads); } } }
/// <summary> /// Event raised when there is an exception on a threadpool thread. /// A thread worker function that processes items from the work queue. /// </summary> private static void ProcessQueuedItems() { // Process indefinitely while (true) { _workerThreadNeeded.WaitOne(); // Get the next item in the queue. If there is nothing there, go to sleep // for a while until we're woken up when a callback is waiting. WaitingCallback callback = null; // Try to get the next callback available. We need to lock on the // queue in order to make our count check and retrieval atomic. lock (_poolLock) { if (_waitingCallbacks.Count > 0) { try { callback = (WaitingCallback)_waitingCallbacks.Dequeue(); } catch (Exception e) { logger.Error("callback回调异常", e); } // make sure not to fail here } } if (callback != null) { // We now have a callback. Execute it. Make sure to accurately // record how many callbacks are currently executing. try { Interlocked.Increment(ref _inUseThreads); callback.Callback(callback.State); } catch (Exception e) { logger.Error("callback回调异常", e); } finally { Interlocked.Decrement(ref _inUseThreads); } } } }
private void ProcessQueuedItems(object threadIndexWithinPool) { // Set the ThreadStatic variable indicating the which thread pool we belong to ThisThreadGlobalThreadPoolIndex = (int)GlobalThreadPoolIndex; if (RoundRobinAffinitize && GlobalThreadPoolIndex != -1) { int processorID = roundRobinAffinitizeProcessorID; if (this.incrementProcessorIDEachThread) { processorID += (int)threadIndexWithinPool; } throw new NotImplementedException("Internal error: AffinitizeThreadRoundRobin needs remediation"); //Native32.AffinitizeThreadRoundRobin((uint)processorID); } while (!shutdown) { WaitingCallback callback = default; bool gotCallback = false; while (!gotCallback) { gotCallback = _waitingCallbacks.TryDequeue(out callback); if (!gotCallback) { _workerThreadNeeded.WaitOne(); } } try { callback.Callback(callback.State); } catch (Exception exc) { throw new Exception("Exception in ThreadPoolManaged worker item " + exc.ToString()); } finally { countdownThreads.Signal(1); } } }
/// <summary>一个线程工作器函数,用于处理工作队列中的项目.</summary> private static void ProcessQueuedItems() { // 无限期地处理 while (true) { _workerThreadNeeded.WaitOne(); //获取队列中的下一个项目。 如果那里什么也没有,那就去睡吧吧 //一段时间,直到我们在回调等待时醒来。 WaitingCallback callback = null; //尝试获取下一个回调。 我们需要锁定 //队列以使我们的计数检查和检索原子。 lock (_poolLock) { if (_waitingCallbacks.Count > 0) { try { callback = (WaitingCallback)_waitingCallbacks.Dequeue(); } catch { } //确保不要在这里失败 } } if (callback != null) { //我们现在有一个回调。 执行它。 确保准确 //记录当前正在执行的回调数。 try { Interlocked.Increment(ref _inUseThreads); callback.Callback(callback.State); } catch (Exception) { } finally { Interlocked.Decrement(ref _inUseThreads); } } } }
/// <summary>清空任何排队工作项的工作队列。 重置池中的所有线程.</summary> public static void Reset() { lock (_poolLock) { // 清理所有等待的回调 try { // 尝试处理所有剩余的状态 foreach (object obj in _waitingCallbacks) { WaitingCallback callback = (WaitingCallback)obj; if (callback.State is IDisposable) { ((IDisposable)callback.State).Dispose(); } } } catch { } // 关闭所有现有线程 try { foreach (Thread thread in _workerThreads) { if (thread != null) { thread.Abort("reset"); } } } catch { } // 重新初始化池(创建新线程等) Initialize(); } }
private static void ProcessQueuedItems() { while (true) { _workerThreadNeeded.WaitOne(); WaitingCallback waitingCallback = null; lock (_poolLock) { if (_waitingCallbacks.Count > 0) { try { waitingCallback = (WaitingCallback)_waitingCallbacks.Dequeue(); } catch { } } } if (waitingCallback != null) { try { Interlocked.Increment(ref _inUseThreads); waitingCallback.Callback(waitingCallback.State); } catch { } finally { Interlocked.Decrement(ref _inUseThreads); } } } }
/// <summary>Queues a user work item to the thread pool.</summary> /// <param name="callback"> /// A WaitCallback representing the delegate to invoke when the thread in the /// thread pool picks up the work item. /// </param> /// <param name="state"> /// The object that is passed to the delegate when serviced from the thread pool. /// </param> public static void QueueUserWorkItem(WaitCallback callback, object state) { // Create a waiting callback that contains the delegate and its state. // At it to the processing queue, and signal that data is waiting. WaitingCallback waiting = new WaitingCallback(callback, state); lock (_poolLock) { _waitingCallbacks.Enqueue(waiting); } _workerThreadNeeded.AddOne(); }
/// <summary>Queues a user work item to the thread pool.</summary> /// <param name="callback"> /// A WaitCallback representing the delegate to invoke when the thread in the /// thread pool picks up the work item. /// </param> /// <param name="state"> /// The object that is passed to the delegate when serviced from the thread pool. /// </param> public void QueueUserWorkItem(WaitCallback callback, object state) { try { // Create a waiting callback that contains the delegate and its state. // Add it to the processing queue, and signal that data is waiting. WaitingCallback waiting = new WaitingCallback(callback, state); lock (_waitingCallbacks.SyncRoot) { _waitingCallbacks.Enqueue(waiting); } _workerThreadNeeded.AddOne(); } catch (System.Exception ex) { Log.Warn("Not expectant exception : ", ex); } }