Does calling WaitOne using a Semaphore release the calling thread to perform other work?

Question

My application needs to perform a number of tasks per tenant on a minute-to-minute basis. These are fire-and-forget operations, so I don't want to use Parallel.ForEach to handle this.

Instead I'm looping through the list of tenants, and firing off a ThreadPool.QueueUserWorkItem to process each tenants task.

foreach (Tenant tenant in tenants)
{
    ThreadPool.QueueUserWorkItem(new WaitCallback(ProcessTenant), tenantAccount);
}

This code works perfectly in production, and can generally process over 100 tenants in under 5 seconds.

However on application startup this causes 100% CPU utilization while things like EF get warmed up during the startup process. To limit this I've implemented a semaphore as follows:

private static Semaphore _threadLimiter = new Semaphore(4, 4);

The idea is to limit this task processing to only be able to use half of the machines logical processors. Inside the ProcessTenant method I call:

try
{
    _threadLimiter.WaitOne();

    // Perform all minute-to-minute tasks
}
finally
{
    _threadLimiter.Release();
}

In testing, this appears to work exactly as expected. CPU utilization on startup stays at around 50% and does not appear to affect how quickly initial startup takes.

So question is mainly around what is actually happening when WaitOne is called. Does this release the thread to work on other tasks - similar to asynchronous calls? The MSDN documentation states that WaitOne: "Blocks the current thread until the current WaitHandle receives a signal."

So I'm just wary that this won't actually allow my web app to continue to utilize this blocked thread while it's waiting, which would make the whole point of this exercise meaningless.

If `ProcessTenant` is a separate thread to your startup, then it's fine. — ProgrammingLlama, Oct 30 '18 at 07:09
@John ProcessTenant is the method being fired by ThreadPool.QueueUserWorkItem, so it's definitely on a seperate thread. — Gary, Oct 30 '18 at 07:15
If you're going to block them, you really should use your own threads rather than the threadpool. Or have one single (dedicated) thread waiting on the semaphore and queue new work when less than 4 items are in the queue — Kevin Gosse, Oct 30 '18 at 07:30

score 1 · Accepted Answer · answered Oct 30 '18 at 07:35

WaitOne does block the thread, and that thread will stop being scheduled on a CPU core until the semaphore is signaled. However, you're holding a large number of threads from the threadpool for possibly a long time ("long" as in "longer than ~500 ms"). This can be an issue because the threadpool grows very slowly, so you may be preventing other part of your application from properly using it.

If you plan on waiting for a significant amount of time, you could use your own threads instead:

foreach (Tenant tenant in tenants)
{
    new Thread(ProcessTenant).Start(tenantAccount);    
}

However, you're still keeping one thread per item in memory. While they won't eat CPU as they're sleeping on the semaphore, they're still using RAM for nothing (about 1MB per thread). Instead, have a single dedicated thread wait on the semaphore and enqueue new items as needed:

// Run this on a dedicated thread
foreach (Tenant tenant in tenants)
{
    _threadLimiter.WaitOne();
    ThreadPool.QueueUserWorkItem(_ => 
    {
        try         
        {
            ProcessTenant(tenantAccount);
        }
        finally
        {
            _threadLimiter.Release();
        }
    });
}

would it make any difference to the thread blocking if I used async all the way, ie. ThreadPool.QueueUserWorkItem(async x => { await ProcessTenant(tenantAccount); }); — Gary, Oct 30 '18 at 08:10
Ok I understand what you saying. I'm effectively queuing up and blocking all my thread pool threads. Even though they do complete pretty quickly, so it should not really be an issue. But it would make more sense to have a single thread that uses the semaphore to queue up the task processing. Thanks! — Gary, Oct 30 '18 at 09:08

Does calling WaitOne using a Semaphore release the calling thread to perform other work?

1 Answers1