Overview

In .NET, multi-threading enables an application to run multiple operations concurrently, making efficient use of system resources. This is crucial for developing responsive applications, performing long-running tasks without freezing the UI, and maximizing the utilization of multi-core processors.

Key Concepts

1. Thread Creation: Creating new threads using the Thread class or the Task class in the System.Threading namespace.
2. Synchronization: Managing access to shared resources across multiple threads to prevent data corruption using locks, mutexes, or other synchronization primitives.
3. Task Parallel Library (TPL): A higher-level abstraction for multi-threading that uses tasks (Task and Task<T>) to make it easier to write concurrent and parallel code.

Common Interview Questions

Basic Level

1. How do you create and start a new thread in a .NET application?
2. What is the difference between the Thread class and Task class for multi-threading?

Intermediate Level

3. How do you handle exceptions in a multi-threaded application?

Advanced Level

4. What are the best practices for managing data access across multiple threads?

Detailed Answers

1. How do you create and start a new thread in a .NET application?

Answer: To create and start a new thread in a .NET application, you use the Thread class found in the System.Threading namespace. You need to pass a ThreadStart delegate or a lambda expression that points to the method the thread will execute to the constructor of the Thread class. Then, you call the Start method on the Thread instance.

Key Points:
- The ThreadStart delegate represents a method that is executed by the thread.
- Threads are started by calling the Start method.
- It's essential to handle exceptions within the thread to avoid unhandled exceptions.

Example:

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        Thread thread = new Thread(new ThreadStart(DoWork));
        thread.Start();
    }

    static void DoWork()
    {
        Console.WriteLine("Thread started");
    }
}

2. What is the difference between the Thread class and Task class for multi-threading?

Answer: The Thread class is a lower-level concept for creating and managing a thread directly, while the Task class, part of the Task Parallel Library (TPL), represents an asynchronous operation. Task provides a higher level of abstraction, making it easier to write concurrent and parallel code. It supports features like returning results, chaining tasks, and handling exceptions more gracefully.

Key Points:
- Thread provides more control but requires more code to manage threading issues.
- Task can automatically use the thread pool, simplifies exception handling, and supports cancellation.
- Task is the preferred approach for new development unless low-level thread management is necessary.

Example:

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Task.Run(() => DoWork());
    }

    static void DoWork()
    {
        Console.WriteLine("Task running");
    }
}

3. How do you handle exceptions in a multi-threaded application?

Answer: In a multi-threaded application, exceptions thrown in child threads must be caught within the same thread. For threads created using the Thread class, you wrap the thread's entry method in a try-catch block. For tasks created with the Task class, you can handle exceptions using the AggregateException class that the task's Wait method or Result property throws.

Key Points:
- Handle exceptions within the thread or task where they occur.
- Use try-catch blocks within thread entry methods.
- For Task, catch AggregateException and iterate through the inner exceptions.

Example:

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        try
        {
            Task task = Task.Run(() => ThrowException());
            task.Wait(); // This will throw an AggregateException
        }
        catch (AggregateException ae)
        {
            foreach (var e in ae.InnerExceptions)
            {
                Console.WriteLine($"Handled exception: {e.Message}");
            }
        }
    }

    static void ThrowException()
    {
        throw new InvalidOperationException("Example exception");
    }
}

4. What are the best practices for managing data access across multiple threads?

Answer: Managing data access across multiple threads requires careful synchronization to avoid race conditions and data corruption. Best practices include using locking mechanisms (lock keyword, Mutex, Semaphore, etc.), using concurrent collections (ConcurrentDictionary, BlockingCollection, etc.) from the System.Collections.Concurrent namespace, and designing your application to minimize shared state and contention.

Key Points:
- Use locks to protect shared resources.
- Prefer using concurrent collections.
- Minimize shared state and access to shared resources to reduce the need for synchronization.

Example:

using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;

class Program
{
    static ConcurrentDictionary<int, string> sharedData = new ConcurrentDictionary<int, string>();

    static void Main()
    {
        Parallel.Invoke(
            () => UpdateSharedData(1, "Value1"),
            () => UpdateSharedData(2, "Value2")
        );

        foreach (var item in sharedData)
        {
            Console.WriteLine($"{item.Key}: {item.Value}");
        }
    }

    static void UpdateSharedData(int key, string value)
    {
        sharedData.AddOrUpdate(key, value, (k, v) => value);
    }
}