public override bool QueueUserWorkItem(Action<CancellationToken, object> target, object userData)
        {
            //User signaled to stop all processing so return false and dont add any new work items.
            if (_poolStopToken.IsCancellationRequested) return false;

            var job = new ThreadPoolWorkItem(target, userData, _poolStopToken);
            while (true)
            {
                //var w = SelectMinLoadRandomNode();
                var w = SelectRoundRobinNode();
                if (w.TaskCount != 0 && _workerKeys.Count < _settings.MaxThreads )
                {
                    lock (_lock)
                    {
                        //new threads are needed. check if pool have capacity and add them now.
                        if (_workerKeys.Count < _settings.MaxThreads)
                        {
                            w = AllocDelegate();
                            _workerThreads.TryAdd(w.Name, w);
                            _workerKeys.Add(w.Name);
                        }
                    }
                }

                if (w.Status == PoolWorkerStatus.Running)
                {
                    w.EnqueueWorkItem(job);
                    EtwLogger.Log.PoolWorkerSelected(w.Name, w.TaskCount);
                    //Console.WriteLine("Assigned to worker: {0}", w.Name);
                    return true;
                }
                else
                {
                    EtwLogger.Log.PoolWorkerAssignmentFailed(w.Name, w.TaskCount);
                    //Console.WriteLine("failed to assign to worker: {0}", w.Name);
                }
            }
        }
        /// <summary>
        /// Enqueues new work to be executed in thread pool.
        /// </summary>
        /// <param name="target">delegate which will execute the work item on thread pool thread</param>
        /// <param name="userData">any user data needed by the delegate</param>
        /// <returns>true if work item is enqueued, false otherwise</returns>
        public override bool QueueUserWorkItem(Action<System.Threading.CancellationToken, object> target, object userData)
        {
            if (_poolStopToken.IsCancellationRequested) return false;
            if (target == null) throw new ArgumentNullException("target");

            var work = new ThreadPoolWorkItem(target, userData, _poolStopToken);
            // If execution context flowing is on, capture the caller’s context.
            if (_settings.EnableExecutionContext)
                work.ExecutionCtx = ExecutionContext.Capture();

            // Now insert the work item into the queue, possibly waking a thread.
            ThreadLocalStealQueue<ThreadPoolWorkItem> wsq = _mWsq;
            if (wsq != null)
            {
                // Single TLS to determine this execution is on a pool thread.
                wsq.LocalPush(work);

                if (wsq.Count > _settings.MinThreads)
                {
                    EnsureThreadCapacity();
                }
            }
            else
            {
                //put item in global queue because this is being added from user's thread
                lock (_mQueue)
                {
                    _mQueue.Enqueue(work);

                    if (_mQueue.Count > _settings.MinThreads)
                    {
                        // Make sure the pool is running with optimal number of required threads.
                        EnsureThreadCapacity();
                    }
                }
            }

            return true;
        }
 private void ExecuteJob(ThreadPoolWorkItem job)
 {
     try
     {
         job.Execute();
     }
     catch (Exception e)
     {
         OnWorkItemException(job, e);
     }
     finally
     {
         Interlocked.Decrement(ref _taskCount);
     }
 }
 private void OnWorkItemException(ThreadPoolWorkItem job, Exception e)
 {
     if (WorkItemExceptionHandler != null)
     {
         WorkItemExceptionHandler(this, new WorkItemEventArgs()
         {
             Exception = e,
             UserData = job == null ? null : job.UserData,
         });
     }
 }
        public bool EnqueueWorkItem(ThreadPoolWorkItem item)
        {
            lock (_queue)
            {
                if (_status != PoolWorkerStatus.Running)
                {
                    //make sure to initialize the thread.
                    return false;
                }

                _queue.Add(item);
                Interlocked.Increment(ref _taskCount);
                return true;
            }
        }