C# Thread Join

Introduction

The Thread.Join method in C# is used to block the calling thread until the thread on which Join is called terminates. This method is useful when you need to ensure that a particular thread has completed its execution before continuing with the rest of your program. The Thread.Join method is part of the System.Threading namespace.

Key Features of Thread.Join

• Blocking Call: Blocks the calling thread until the specified thread terminates.
• Overloads: Provides overloads to specify a timeout period or to check for thread termination without blocking indefinitely.
• Synchronization: Helps synchronize the execution of multiple threads.

Using Thread.Join

Example

using System;
using System.Threading;

namespace ThreadJoinExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // Creating a new thread
            Thread workerThread = new Thread(DoWork);
            workerThread.Start();

            // Main thread continues to work
            for (int i = 0; i < 3; i++)
            {
                Console.WriteLine($"Main thread working... {i}");
                Thread.Sleep(500); // Simulate work
            }

            // Wait for the worker thread to complete
            Console.WriteLine("Main thread waiting for worker thread to complete...");
            workerThread.Join();

            Console.WriteLine("Worker thread has completed. Main thread exiting.");
        }

        static void DoWork()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine($"Worker thread working... {i}");
                Thread.Sleep(1000); // Simulate work
            }
        }
    }
}

Output

Main thread working... 0
Worker thread working... 0
Main thread working... 1
Worker thread working... 1
Main thread working... 2
Worker thread working... 2
Main thread waiting for worker thread to complete...
Worker thread working... 3
Worker thread working... 4
Worker thread has completed. Main thread exiting.

Using Thread.Join with Timeout

You can use the Thread.Join method with a timeout to specify how long the calling thread should wait for the specified thread to terminate. This is useful if you want to avoid blocking indefinitely.

Example

using System;
using System.Threading;

namespace ThreadJoinTimeoutExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // Creating a new thread
            Thread workerThread = new Thread(DoWork);
            workerThread.Start();

            // Main thread continues to work
            for (int i = 0; i < 3; i++)
            {
                Console.WriteLine($"Main thread working... {i}");
                Thread.Sleep(500); // Simulate work
            }

            // Wait for the worker thread to complete with a timeout
            Console.WriteLine("Main thread waiting for worker thread to complete with timeout...");
            bool completed = workerThread.Join(2000); // Wait for 2 seconds

            if (completed)
            {
                Console.WriteLine("Worker thread has completed within timeout. Main thread exiting.");
            }
            else
            {
                Console.WriteLine("Worker thread did not complete within timeout. Main thread exiting.");
            }
        }

        static void DoWork()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine($"Worker thread working... {i}");
                Thread.Sleep(1000); // Simulate work
            }
        }
    }
}

Output

Main thread working... 0
Worker thread working... 0
Main thread working... 1
Worker thread working... 1
Main thread working... 2
Worker thread working... 2
Main thread waiting for worker thread to complete with timeout...
Worker thread working... 3
Worker thread working... 4
Worker thread did not complete within timeout. Main thread exiting.

Practical Example: Downloading Files

Let’s create a practical example where the main thread waits for multiple worker threads to download files concurrently.

Example

using System;
using System.Threading;

namespace MultiThreadJoinExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // Array of URLs to download
            string[] urls = { "file1", "file2", "file3" };

            // Array of threads
            Thread[] threads = new Thread[urls.Length];

            // Start each download in a separate thread
            for (int i = 0; i < urls.Length; i++)
            {
                int index = i; // Capture the loop variable
                threads[i] = new Thread(() => DownloadFile(urls[index]));
                threads[i].Start();
            }

            // Wait for all threads to complete
            foreach (Thread thread in threads)
            {
                thread.Join();
            }

            Console.WriteLine("All downloads completed.");
        }

        static void DownloadFile(string url)
        {
            Console.WriteLine($"Starting download: {url}");
            Thread.Sleep(2000); // Simulate download time
            Console.WriteLine($"Completed download: {url}");
        }
    }
}

Output

Starting download: file1
Starting download: file2
Starting download: file3
Completed download: file1
Completed download: file2
Completed download: file3
All downloads completed.

Conclusion

The Thread.Join method in C# is used for synchronizing threads, ensuring that one thread waits for another to complete before proceeding. It is particularly useful for scenarios where you need to coordinate the completion of multiple threads or ensure that resources are cleaned up properly. By understanding and using the Thread.Join method effectively, you can manage thread execution and synchronization in your applications.