Okay, today it was re enforced that the ThreadPool is not good for long running tasks, specifically those that might use the ThreadPool or use async methods or ResetEvents. I didn’t really track down the root cause, but generally it locked while waiting for a set event. Regardless, the solution as is usually the case was to simplify the code. First by not using a ResetEvent and ThreadPooling for queuing the workload. In place of that a simple QueueRunner class was created using the Monitor class. Using the Monitor.Wait and Monitor.Pulse was new to me, but works well and seems to be very fast. There is a great article here about threading in c#. I’m not going to re-explain what already been said there, but below is the code. It could be enhanced for other uses and performance.

[TestFixture]
public class QueueRunnerTest
{
private int _count = 0;

[Test]
public void Test100ExpectSuccess()
{
Queue<int> queue = new Queue<int>();
for (int i = 0; i < 100; i++)
queue.Enqueue(i);

_count = 0;

QueueRunner<int> runner = new QueueRunner<int>(Work, queue);
runner.RunAndWait();

Assert.That(_count, Is.EqualTo(100));
}

private void Work(object obj)
{
Console.WriteLine("Working " + obj);
Interlocked.Increment(ref _count);
}
}

class QueueRunner<T>
{
private readonly object _syncLock = new object();
private readonly Queue<T> _queue = new Queue<T>();
private int _running = 0;
private readonly int _maxThreads;
private readonly ParameterizedThreadStart _workerDelegate;
private int _toBeCompleted = 0;

public QueueRunner(ParameterizedThreadStart workerDelegate, Queue<T> queue)
: this(workerDelegate, queue, 5)
{
}

public QueueRunner(ParameterizedThreadStart workerDelegate, Queue<T> queue, int maxThreads)
{
_workerDelegate = workerDelegate;
_maxThreads = maxThreads;
_queue = queue;
_toBeCompleted = _queue.Count;
}

public void RunAndWait()
{
new Thread(Start).Start();
Wait();
}

private void Start()
{
lock (_syncLock)
while (_queue.Count > 0)
{
while (_running < _maxThreads)
{
new Thread(DelegateWrapper).Start(_queue.Dequeue());
Interlocked.Increment(ref _running);
}
Monitor.Wait(_syncLock);
}
}

private void DelegateWrapper(object state)
{
_workerDelegate(state);
DecrementCount();
}

private void Wait()
{
lock (_syncLock)
while (_toBeCompleted > 0)
Monitor.Wait(_syncLock);
}

private void DecrementCount()
{
Interlocked.Decrement(ref _running);
Interlocked.Decrement(ref _toBeCompleted);
lock (_syncLock)
Monitor.PulseAll(_syncLock);
}
}
</p>

Resources:
Threading in C# - Joseph Albahari
Delegate BeginInvoke and ManualResetEvent.WaitOne()