Question

Requirement :- At any given point of time only 4 threads should be calling four different functions. As soon as these threads complete, next available thread should call the same functions.

Current code :- This seems to be the worst possible way to achieve something like this. While(True) will cause unnecessary CPU spikes and i could see CPU rising to 70% when running the following code.

Question :- How can i use AutoResetEventHandler to signal Main thread Process() function to start next 4 threads again once the first 4 worker threads are done processing without wasting CPU cycles. Please suggest

public class Demo
{
    object protect = new object();
    private int counter;
    public void Process()
    {
        int maxthread = 4;
        while (true)
        {
            if (counter <= maxthread)
            {
                counter++;
                Thread t = new Thread(new ThreadStart(DoSomething));
                t.Start();
            }
        }
    }
    private void DoSomething()
    {
        try
        {
            Thread.Sleep(50000); //simulate long running process
        }
        finally
        {
            lock (protect)
            {
                counter--;
            }
        }
    }

Answer 1

You can use TPL to achieve what you want in a simpler way. If you run the code below you’ll notice that an entry is written after each thread terminates and only after all four threads terminate the "Finished batch" entry is written.

This sample uses the Task.WaitAll to wait for the completion of all tasks. The code uses an infinite loop for illustration purposes only, you should calculate the hasPendingWork condition based on your requirements so that you only start a new batch of tasks if required.

For example:

private static void Main(string[] args)
{
    bool hasPendingWork = true;
    do
    {
        var tasks = InitiateTasks();

        Task.WaitAll(tasks);

        Console.WriteLine("Finished batch...");
    } while (hasPendingWork);
}

private static Task[] InitiateTasks()
{
    var tasks = new Task[4];

    for (int i = 0; i < tasks.Length; i++)
    {
        int wait = 1000*i;

        tasks[i] = Task.Factory.StartNew(() =>
        {
            Thread.Sleep(wait);
            Console.WriteLine("Finished waiting: {0}", wait);
        });
    }

    return tasks;
}

One other thing, from the textual requirement section on your question I’m lead to believe that a batch of four new threads should only start after all previously four threads completed. However the code you posted is not compatible with that requirement, since it starts a new thread immediately after a previous thread terminate. You should clarify what exactly is your requirement.

---

UPDATE:

If you want to start a thread immediately after one of the four threads terminate you can still use TPL instead of starting new threads explicitly but you can limit the number of running threads to four by using a SemaphoreSlim. For example:

private static SemaphoreSlim TaskController = new SemaphoreSlim(4);

private static void Main(string[] args)
{
    var random = new Random(570);

    while (true)
    {
        // Blocks thread without wasting CPU
        // if the number of resources (4) is exhausted
        TaskController.Wait();

        Task.Factory.StartNew(() =>
        {
            Console.WriteLine("Started");
            Thread.Sleep(random.Next(1000, 3000));
            Console.WriteLine("Completed");
            // Releases a resource meaning TaskController.Wait will unblock
            TaskController.Release();
        });
    }
}