How do you handle exceptions in a multithreaded environment?

Question

Ravi Vishwakarma · Answer

Handling exceptions in a multithreaded environment in C# requires careful consideration because exceptions thrown in worker threads do not propagate to the main thread. Here are some best practices to handle exceptions in a multithreaded application
and 
1. Using try-catch in Each Thread
Every thread should have its own try-catch block to prevent unhandled exceptions from terminating the process.
Example
using System;
using System.Threading;
class Program
{
    static void Main()
    {
        Thread thread = new Thread(() =andgt;
        {
            try
            {
                throw new Exception("Error in thread!");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Caught exception in thread: {ex.Message}");
            }
        });
        thread.Start();
        thread.Join();
        Console.WriteLine("Main thread continues...");
    }
}
Output:
Caught exception in thread: Error in thread!
Main thread continues...
and 
2. Handling Exceptions in Tasks (Task.Exception)
When using Tasks (Task.Run or Task.Factory.StartNew), unhandled exceptions are stored in the
Exception property of the Task. You must call .Wait() or
.Result to propagate the exception.
Example
using System;
using System.Threading.Tasks;
class Program
{
    static void Main()
    {
        Task task = Task.Run(() =andgt;
        {
            throw new Exception("Task error!");
        });
        try
        {
            task.Wait(); // Propagates exception
        }
        catch (AggregateException ae)
        {
            foreach (var ex in ae.InnerExceptions)
            {
                Console.WriteLine($"Caught exception: {ex.Message}");
            }
        }
    }
}
Key Takeaway:
Use .Wait() or .Result to catch exceptions in 
Task.Run.Always handle AggregateException, which wraps multiple exceptions.
and 
3. Using Task.ContinueWith for Exception Handling
Instead of blocking with .Wait(), use ContinueWith to handle exceptions asynchronously.
Example
Task.Run(() =andgt;
{
    throw new Exception("Something went wrong in the task!");
})
.ContinueWith(t =andgt;
{
    if (t.IsFaulted)
    {
        foreach (var ex in t.Exception!.InnerExceptions)
        {
            Console.WriteLine($"Caught exception: {ex.Message}");
        }
    }
});
Key Takeaway:
ContinueWith ensures exceptions are handled without blocking execution.
and 
4. Using a Global Exception Handling Mechanism
For larger applications, especially in ASP.NET or Windows Services, a centralized exception handling strategy is useful.
and 
For Background Threads (AppDomain.UnhandledException)
If exceptions escape a thread, they can be caught globally:
AppDomain.CurrentDomain.UnhandledException += (sender, e) =andgt;
{
    Console.WriteLine($"Unhandled exception: {((Exception)e.ExceptionObject).Message}");
};
and 
For Tasks (TaskScheduler.UnobservedTaskException)
TaskScheduler.UnobservedTaskException += (sender, e) =andgt;
{
    foreach (var ex in e.Exception.InnerExceptions)
    {
        Console.WriteLine($"Unobserved exception: {ex.Message}");
    }
    e.SetObserved(); // Prevents application crash
};
Key Takeaway:
These event handlers catch exceptions that were not explicitly handled.
and 
5. Using ConcurrentQueue for Exception Logging
If multiple threads are running, exceptions can be logged safely using a thread-safe queue.
Example
using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
class Program
{
    static ConcurrentQueueandlt;Exceptionandgt; exceptionQueue = new ConcurrentQueueandlt;Exceptionandgt;();
    static void Main()
    {
        Task task = Task.Run(() =andgt;
        {
            try
            {
                throw new Exception("Background thread error!");
            }
            catch (Exception ex)
            {
                exceptionQueue.Enqueue(ex);
            }
        });
        task.Wait();
        // Process exceptions safely
        while (exceptionQueue.TryDequeue(out Exception? ex))
        {
            Console.WriteLine($"Logged exception: {ex.Message}");
        }
    }
}
Key Takeaway:
ConcurrentQueueandlt;Exceptionandgt; ensures exceptions from multiple threads are stored safely for later processing.
and 
Summary
Approach
Best For
Notes
try-catch inside thread
Simple threads
Ensures exceptions are handled per thread
.Wait() or .Result
Task.Run()
Use AggregateException for multiple exceptions
.ContinueWith()
Asynchronous handling
Non-blocking error handling
AppDomain.UnhandledException
Global handling
Catches unhandled exceptions in background threads
ConcurrentQueueandlt;Exceptionandgt;
Logging exceptions
Stores exceptions safely from multiple threads
and

interview

How do you handle exceptions in a multithreaded environment?

Ravi Vishwakarma

Can you answer this question?

1 Answers

1. Using try-catch in Each Thread

2. Handling Exceptions in Tasks (`Task.Exception`)

3. Using `Task.ContinueWith` for Exception Handling

4. Using a Global Exception Handling Mechanism

5. Using `ConcurrentQueue` for Exception Logging

Summary

Liked By

Approach	Best For	Notes
`try-catch` inside thread	Simple threads	Ensures exceptions are handled per thread
`.Wait()` or `.Result`	`Task.Run()`	Use `AggregateException` for multiple exceptions
`.ContinueWith()`	Asynchronous handling	Non-blocking error handling
`AppDomain.UnhandledException`	Global handling	Catches unhandled exceptions in background threads
`ConcurrentQueue<Exception>`	Logging exceptions	Stores exceptions safely from multiple threads