Thread Pooling in C#

The ThreadPool.QueueUserWorkItem method allows us to launch the execution of a function on the system thread pool. Its declaration is as follows:

ThreadPool.QueueUserWorkItem(new WaitCallback(Consume), ware);

The first parameter specifies the function that we want to execute on the pool. Its signature must match the delegate WaitCallback.

Again, the simplicity of C# and the dotNet framework shine through. In just a few lines of code, I've recreated a multithreaded consumer-producer application.

using System;
using System.Threading;
using System.Diagnostics;
public class Akshay
{
public int id;
public Akshay(int _id)
{
id = _id;
}
}
class Class1
{
public int QueueLength;
public Class1()
{
QueueLength = 0;
}
public void Produce(Akshay ware)
{
ThreadPool.QueueUserWorkItem(
new WaitCallback(Consume), ware);
QueueLength++;
}
public void Consume(Object obj)
{
Console.WriteLine("Thread {0} consumes {1}",
Thread.CurrentThread.GetHashCode(), //{0}
((Akshay)obj).id); //{1}
Thread.Sleep(100);
QueueLength--;
}
public static void Main(String[] args)
{
Class1 obj = new Class1();
for (int i = 0; i < 100; i++)
{
obj.Produce(new Akshay(i));
}
Console.WriteLine("Thread {0}",
Thread.CurrentThread.GetHashCode() ); //{0}
while (obj.QueueLength != 0)
{
Thread.Sleep(1000);
}
Console.Read();
}
}

Ouput :

Synchronization Objects

The previous code contains some rather inefficient coding when the main thread cleans up. I repeatedly test the queue length every second until the queue length reaches zero. This may mean that the process will continue executing for up to a full second after the queues are finally drained. I can't have that.

The following example uses a ManualResetEvent Event object that will signal the main thread to exit.

using System;
using System.Threading;
using System.Diagnostics;
public class Akshay
{
private bool WaitForComplete;
private ManualResetEvent Event;
public int QueueLength;
public int id;
public Akshay(int _id)
{
id = _id;
}
public void Wait()
{
if (QueueLength == 0)
{
return;
}
Event = new ManualResetEvent(false);
WaitForComplete = true;
Event.WaitOne();
}
public void Consume(Object obj)
{
Console.WriteLine("Thread {0} consumes {1}",
Thread.CurrentThread.GetHashCode(), //{0}
((Akshay)obj).id); //{1}
Thread.Sleep(100);
QueueLength--;
if (WaitForComplete)
{
if (QueueLength == 0)
{
Event.Set();
}
};
}
}

Ouput :

When the consuming thread finishes consuming a ware and detects that the WaitForComplete is true, it will trigger the Event when the queue length is zero. Instead of calling the while block when it wants to exit, the main thread calls the Wait instance method. This method sets the WaitForComplete flag and waits on the Event object.

Why we need thread pooling?

Thread pooling is essential in multithreaded applications for the following reasons.

• Thread pooling improves the response time of an application as threads are already available in the thread pool waiting for their next assignment and do not need to be created from scratch.

• Thread pooling saves the CLR from the overhead of creating an entirely new thread for every short-lived task and reclaiming its resources once it dies.

• Thread pooling optimizes the thread time slices according to the current process running in the system.

• Thread pooling enables us to start several tasks without having to set the properties for each thread.

• Thread pooling enables us to state information as an object to the procedure arguments of the task that is being executed.

• Thread pooling can be employed to fix the maximum number of threads for processing a particular request.