Implementing Multiple Thread Creation and Waiting for Completion in C#

Introduction

In multithreaded programming, creating multiple concurrently executing threads and waiting for all of them to complete is a common requirement. In C# and the .NET framework, various methods exist to achieve this, ranging from traditional thread management to modern parallel task libraries. This article systematically introduces these methods, with a focus on analyzing their core mechanisms and applicable scenarios.

Modern Thread Management with Tasks (.NET 4.0 and Above)

Since the introduction of the Task Parallel Library (TPL) in .NET 4.0, thread management has become more concise and efficient. The Task class provides a high-level abstraction that simplifies the creation and synchronization of parallel operations. The following example demonstrates how to create multiple threads and wait for their completion using Task:

class Program
{
    static void Main(string[] args)
    {
        Task task1 = Task.Factory.StartNew(() => doStuff());
        Task task2 = Task.Factory.StartNew(() => doStuff());
        Task task3 = Task.Factory.StartNew(() => doStuff());

        Task.WaitAll(task1, task2, task3);
        Console.WriteLine("All threads complete");
    }

    static void doStuff()
    {
        // Perform specific tasks
    }
}

In this example, the Task.Factory.StartNew() method is used to launch new tasks, each running the doStuff() method on a separate thread. Task.WaitAll() blocks the main thread until all specified tasks have finished execution. This approach automatically handles thread pool management, reducing the overhead of manual thread creation and improving scalability.

Traditional Thread Synchronization Methods (Pre-.NET 4.0)

In earlier .NET versions, developers commonly used the Thread class to directly create and manage threads, with synchronization achieved via the Thread.Join() method. The following code illustrates this traditional approach:

static void Main(string[] args)
{
    Thread t1 = new Thread(doStuff);
    t1.Start();

    Thread t2 = new Thread(doStuff);
    t2.Start();

    Thread t3 = new Thread(doStuff);
    t3.Start();

    t1.Join();
    t2.Join();
    t3.Join();

    Console.WriteLine("All threads complete");
}

Here, each Thread object represents an independent execution thread, the Start() method initiates the thread, and Join() causes the main thread to wait for each thread to terminate. While this method offers lower-level control, it requires manual management of thread lifecycles, which can lead to resource leaks or performance issues, especially in high-concurrency scenarios.

Supplementary Synchronization Techniques

Beyond the core methods, the .NET framework provides additional synchronization mechanisms. For instance, WaitHandle.WaitAll() can be used to wait for multiple event handles, suitable for more complex thread coordination scenarios. A simplified example is as follows:

WaitHandle[] waitHandles = new WaitHandle[3];
// Initialize events and threads
WaitHandle.WaitAll(waitHandles);

Moreover, the Task.WhenAll() method is ideal for asynchronous programming models, particularly when tasks return values. It returns a task that completes when all input tasks have finished, collecting results and avoiding the complexity of manual synchronization. For example:

var tasks = new[]
{
    Task.Factory.StartNew(() => GetSomething1()),
    Task.Factory.StartNew(() => GetSomething2()),
    Task.Factory.StartNew(() => GetSomething3())
};
var results = await Task.WhenAll(tasks);

Performance and Applicability Analysis

In modern applications, Task-based approaches are recommended due to their better integration with .NET's asynchronous patterns and optimization of resource usage via thread pools. The traditional Thread.Join() method remains valuable for scenarios requiring fine-grained control over thread behavior or maintaining legacy code. The choice of method should consider framework version, performance requirements, and code maintainability.

Conclusion

Implementing multithreaded synchronization in C# offers multiple pathways, from the straightforward Task.WaitAll() to the traditional Thread.Join(). Developers should select the most appropriate tool based on specific contexts. With the evolution of the .NET ecosystem, the Task Parallel Library has become the mainstream, providing robust and user-friendly support for parallel programming.