C# Multithreading

Multithreading is a powerful feature in C# that allows applications to perform multiple operations concurrently. By leveraging multithreading, developers can create responsive and efficient applications that utilize system resources effectively. Understanding multithreading is essential for building high-performance applications, especially those that require parallel processing, real-time data handling, or maintaining responsive user interfaces.

1. Introduction to Multithreading

Multithreading enables the execution of multiple threads within a single process. Each thread represents an independent path of execution, allowing tasks to run concurrently. Multithreading can significantly improve the performance and responsiveness of applications by utilizing multiple CPU cores and performing tasks in parallel.

Key Concepts:
- Thread: The smallest unit of processing that can be scheduled by the operating system.

- Concurrency vs. Parallelism: Concurrency involves managing multiple tasks by interleaving their execution, while parallelism involves executing multiple tasks simultaneously on different cores.

- Thread Safety: Ensuring that shared resources are accessed and modified correctly when multiple threads are involved.

- Synchronization: Mechanisms to control the access of multiple threads to shared resources to prevent race conditions and ensure data consistency.

2. Thread Basics

2.1 The Thread Class

The `System.Threading.Thread` class represents a thread in C#. It provides methods and properties to create, control, and manage threads.

Example: Creating and Starting a Thread

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        Thread newThread = new Thread(new ThreadStart(PrintNumbers));
        newThread.Start(); // Starts the new thread

        for(int i = 1; i <= 5; i++)
        {
            Console.WriteLine($"Main Thread: {i}");
            Thread.Sleep(500); // Pause for 500 milliseconds
        }
    }

    static void PrintNumbers()
    {
        for(int i = 1; i <= 5; i++)
        {
            Console.WriteLine($"New Thread: {i}");
            Thread.Sleep(1000); // Pause for 1 second
        }
    }
}/

Sample Output:
Main Thread: 1
New Thread: 1
Main Thread: 2
Main Thread: 3
New Thread: 2
Main Thread: 4
Main Thread: 5
New Thread: 3
New Thread: 4
New Thread: 5

Explanation:
- Creating a Thread: `new Thread(new ThreadStart(PrintNumbers))` creates a new thread that will execute the `PrintNumbers` method.
- Starting a Thread: `newThread.Start()` begins the execution of the new thread.
- Main Thread vs. New Thread: Both the main thread and the new thread execute concurrently, interleaving their outputs based on the `Sleep` durations.

2.2 Thread Lifecycle

Threads go through various states during their lifecycle:
1. Unstarted: The thread has been created but not yet started.
2. Running: The thread is currently executing.
3. WaitSleepJoin: The thread is blocked, waiting, sleeping, or joining another thread.
4. Stopped: The thread has finished execution or has been aborted.

3. Thread Pool

Thread Pool is a collection of worker threads managed by the .NET runtime. Utilizing the thread pool can improve performance by reusing existing threads instead of creating new ones for each task.

Example: Using ThreadPool to Queue Work

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoWork));
        Console.WriteLine("Main thread does some work, then waits.");
        Thread.Sleep(1000); // Wait for the thread pool thread to complete
        Console.WriteLine("Main thread exits.");
    }

    static void DoWork(object state)
    {
        Console.WriteLine("ThreadPool thread starts working.");
        Thread.Sleep(500); // Simulate work
        Console.WriteLine("ThreadPool thread completes work.");
    }
}

Sample Output:
Main thread does some work, then waits.
ThreadPool thread starts working.
ThreadPool thread completes work.
Main thread exits.

Explanation:
- QueueUserWorkItem: Queues a method to the thread pool for execution.
- DoWork Method: Executes on a thread pool thread, performing the simulated work.
- Synchronization: The main thread sleeps to allow the thread pool thread to complete before exiting.

2.3 Background vs. Foreground Threads

- Foreground Threads: Keep the application running until they complete. The application does not terminate until all foreground threads have finished.
- Background Threads: Do not prevent the application from terminating. The application can exit even if background threads are still running.

Example: Foreground vs. Background Threads

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        Thread foregroundThread = new Thread(DoWork);
        foregroundThread.IsBackground = false; // Foreground thread
        foregroundThread.Start();

        Thread backgroundThread = new Thread(DoWork);
        backgroundThread.IsBackground = true; // Background thread
        backgroundThread.Start();

        Console.WriteLine("Main thread ends.");
    }

    static void DoWork()
    {
        for(int i = 1; i <= 3; i++)
        {
            Console.WriteLine($"{Thread.CurrentThread.IsBackground ? "Background" : "Foreground"} Thread: {i}");
            Thread.Sleep(1000);
        }
    }
}

Sample Output:
Foreground Thread: 1
Background Thread: 1
Foreground Thread: 2
Background Thread: 2
Foreground Thread: 3
Background Thread: 3
Main thread ends.

Explanation:
- Foreground Thread: Completes its work, ensuring the application remains alive until it finishes.
- Background Thread: May be terminated abruptly when the main thread ends, but in this case, both threads finish before the main thread exits.

4. Synchronization

When multiple threads access shared resources, synchronization is crucial to prevent race conditions and ensure data consistency. C# provides several synchronization mechanisms:

4.1 Lock Statement

The `lock` statement ensures that a block of code runs exclusively, allowing only one thread to execute it at a time.

Example: Using Lock to Synchronize Access

using System;
using System.Threading;

class Program
{
    static int counter = 0;
    static readonly object locker = new object();

    static void Main()
    {
        Thread t1 = new Thread(IncrementCounter);
        Thread t2 = new Thread(IncrementCounter);
        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
        Console.WriteLine($"Final Counter Value: {counter}");
    }

    static void IncrementCounter()
    {
        for(int i = 0; i < 100000; i++)
        {
            lock(locker)
            {
                counter++;
            }
        }
    }
}

Sample Output:
Final Counter Value: 200000

Explanation:
- Shared Resource: The `counter` variable is accessed by both threads.
- Lock Object: `locker` is used to synchronize access to the `counter`.
- Lock Statement: Ensures that only one thread can increment the counter at a time, preventing race conditions.

4.2 Monitor Class

The `Monitor` class provides more control over synchronization compared to the `lock` statement, allowing for finer-grained synchronization mechanisms like waiting and signaling.

Example: Using Monitor to Synchronize Access

using System;
using System.Threading;

class Program
{
    static int counter = 0;
    static readonly object monitorLock = new object();

    static void Main()
    {
        Thread t1 = new Thread(IncrementWithMonitor);
        Thread t2 = new Thread(IncrementWithMonitor);
        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
        Console.WriteLine($"Final Counter Value: {counter}");
    }

    static void IncrementWithMonitor()
    {
        for(int i = 0; i < 100000; i++)
        {
            Monitor.Enter(monitorLock);
            try
            {
                counter++;
            }
            finally
            {
                Monitor.Exit(monitorLock);
            }
        }
    }
}

Sample Output:
Final Counter Value: 200000

Explanation:
- Monitor.Enter and Monitor.Exit: Explicitly acquire and release the lock.
- try-finally Block: Ensures that the lock is released even if an exception occurs within the locked section.

4.3 Mutex

A `Mutex` is similar to a `lock` but can be used for inter-process synchronization, allowing threads from different processes to synchronize access to a resource.

Example: Using Mutex for Inter-Process Synchronization

using System;
using System.Threading;

class Program
{
    static Mutex mutex = new Mutex(false, "Global\\MyMutex");

    static void Main()
    {
        Console.WriteLine("Attempting to acquire mutex...");
        if(mutex.WaitOne(TimeSpan.FromSeconds(5), false))
        {
            try
            {
                Console.WriteLine("Mutex acquired. Performing work...");
                Thread.Sleep(3000); // Simulate work
            }
            finally
            {
                mutex.ReleaseMutex();
                Console.WriteLine("Mutex released.");
            }
        }
        else
        {
            Console.WriteLine("Could not acquire mutex.");
        }
    }
}

Sample Output:
Attempting to acquire mutex...
Mutex acquired. Performing work...
Mutex released.

Explanation:
- Global Mutex: Named mutex `"Global\\MyMutex"` can be shared across processes.
- WaitOne Method: Attempts to acquire the mutex within a specified timeout.
- ReleaseMutex Method: Releases the mutex, allowing other threads or processes to acquire it.

4.4 Semaphore and SemaphoreSlim

Semaphore controls access to a resource pool with a limited number of concurrent accesses. SemaphoreSlim is a lightweight alternative suitable for intra-process synchronization.

Example: Using SemaphoreSlim to Limit Concurrent Access

using System;
using System.Threading;

class Program
{
    static SemaphoreSlim semaphore = new SemaphoreSlim(2); // Allows up to 2 concurrent threads

    static void Main()
    {
        for(int i = 1; i <= 5; i++)
        {
            Thread t = new Thread(() => AccessResource(i));
            t.Start();
        }
    }

    static void AccessResource(int id)
    {
        Console.WriteLine($"Thread {id} waiting to access resource.");
        semaphore.Wait();
        try
        {
            Console.WriteLine($"Thread {id} has entered the resource.");
            Thread.Sleep(2000); // Simulate work
            Console.WriteLine($"Thread {id} is leaving the resource.");
        }
        finally
        {
            semaphore.Release();
        }
    }
}

Sample Output:
Thread 1 waiting to access resource.
Thread 2 waiting to access resource.
Thread 3 waiting to access resource.
Thread 4 waiting to access resource.
Thread 5 waiting to access resource.
Thread 1 has entered the resource.
Thread 2 has entered the resource.
Thread 1 is leaving the resource.
Thread 3 has entered the resource.
Thread 2 is leaving the resource.
Thread 4 has entered the resource.
Thread 3 is leaving the resource.
Thread 5 has entered the resource.
Thread 4 is leaving the resource.
Thread 5 is leaving the resource.

Explanation:
- SemaphoreSlim Initialization: Allows up to 2 threads to access the resource concurrently.
- Wait Method: Each thread waits until it can enter the semaphore.
- Release Method: Each thread releases the semaphore after completing its work, allowing other threads to enter.

5. Task Parallel Library (TPL)

The Task Parallel Library provides higher-level abstractions for parallel programming, simplifying the process of writing concurrent and asynchronous code. It includes the `Task` class, parallel loops, and PLINQ (Parallel LINQ).

5.1 The Task Class

The `System.Threading.Tasks.Task` class represents an asynchronous operation. Tasks can be used to run code concurrently without manually managing threads.

Example: Creating and Running a Task

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Task task = Task.Run(() => DoWork());
        Console.WriteLine("Main thread continues...");
        task.Wait(); // Wait for the task to complete
        Console.WriteLine("Task completed.");
    }

    static void DoWork()
    {
        for(int i = 1; i <= 5; i++)
        {
            Console.WriteLine($"Task: {i}");
            Task.Delay(500).Wait(); // Pause for 500 milliseconds
        }
    }
}

Sample Output:
Main thread continues...
Task: 1
Task: 2
Task: 3
Task: 4
Task: 5
Task completed.

Explanation:
- Task.Run: Schedules the `DoWork` method to run on a thread pool thread.
- Main Thread Continues: The main thread does not wait for the task unless explicitly told to (`task.Wait()`).
- Task Completion: The main thread waits for the task to finish before exiting.

5.2 Parallel Class

The `System.Threading.Tasks.Parallel` class provides methods for parallel loops and regions, enabling data parallelism.

Example: Using Parallel.For to Iterate Concurrently

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Parallel.For(1, 6, i =>
        {
            Console.WriteLine($"Parallel.For iteration {i} on thread {Task.CurrentId}");
            Task.Delay(1000).Wait(); // Simulate work
        });
        Console.WriteLine("Parallel.For loop completed.");
    }
}

Sample Output:
Parallel.For iteration 1 on thread 1
Parallel.For iteration 2 on thread 2
Parallel.For iteration 3 on thread 3
Parallel.For iteration 4 on thread 4
Parallel.For iteration 5 on thread 5
Parallel.For loop completed.

Explanation:
- Parallel.For: Executes iterations in parallel, utilizing multiple threads.
- Task.CurrentId: Identifies the task executing the current iteration.
- Loop Completion: The loop waits until all iterations are complete before continuing.

5.3 Async and Await

The `async` and `await` keywords simplify asynchronous programming by allowing code to be written in a synchronous style while performing asynchronous operations.

Example: Asynchronous Method with Async and Await

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Console.WriteLine("Main thread starts.");
        await PerformTaskAsync();
        Console.WriteLine("Main thread ends.");
    }

    static async Task PerformTaskAsync()
    {
        Console.WriteLine("Task starts.");
        await Task.Delay(2000); // Simulate asynchronous work
        Console.WriteLine("Task ends.");
    }
}

Sample Output:
Main thread starts.
Task starts.
Task ends.
Main thread ends.

Explanation:
- Async Method: `PerformTaskAsync` is marked with `async` and returns a `Task`.
- Await Keyword: `await Task.Delay(2000)` asynchronously waits for 2 seconds without blocking the main thread.
- Program Flow: The main thread starts, performs the asynchronous task, and then ends after the task completes.

5.4 PLINQ (Parallel LINQ)

PLINQ leverages multiple processors to perform LINQ queries in parallel, enhancing performance for large data sets.

Example: Using PLINQ to Process Data Concurrently

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        var numbers = Enumerable.Range(1, 10).ToArray();
        var parallelResult = numbers.AsParallel()
                                    .Where(n => n % 2 == 0)
                                    .Select(n => n * n)
                                    .ToArray();

        Console.WriteLine("PLINQ Results:");
        foreach(var num in parallelResult)
        {
            Console.WriteLine(num);
        }
        // Output (order may vary):
        // 4
        // 16
        // 36
        // 64
        // 100
    }
}

Sample Output:
PLINQ Results:
4
16
36
64
100

Explanation:
- AsParallel: Converts the collection to a parallel query.
- Where and Select: Filters even numbers and squares them concurrently.
- ToArray: Materializes the results into an array.

6. Thread Safety

Ensuring thread safety is crucial when multiple threads access shared resources. Without proper synchronization, race conditions, deadlocks, and data corruption can occur.

6.1 Immutable Objects

Immutable objects are inherently thread-safe as their state cannot change after creation.

Example: Immutable Class

using System;

public sealed class ImmutablePerson
{
    public string Name { get; }
    public int Age { get; }

    public ImmutablePerson(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

class Program
{
    static void Main()
    {
        ImmutablePerson person = new ImmutablePerson("Alice", 30);
        Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
    }
}

Output:
Name: Alice, Age: 30

Explanation:
- Sealed Class: Prevents inheritance, ensuring immutability.
- Read-Only Properties: `Name` and `Age` can only be set during object construction.

6.2 Volatile Keyword

The `volatile` keyword ensures that a field is always read from and written to the main memory, preventing the compiler from applying certain optimizations that could lead to inconsistent values across threads.

Example: Using Volatile for Shared Variable

using System;
using System.Threading;

class Program
{
    static volatile bool _shouldStop = false;

    static void Main()
    {
        Thread worker = new Thread(DoWork);
        worker.Start();

        Console.WriteLine("Press any key to stop the worker thread...");
        Console.ReadKey();
        _shouldStop = true;

        worker.Join();
        Console.WriteLine("Worker thread stopped.");
    }

    static void DoWork()
    {
        while (!_shouldStop)
        {
            Console.WriteLine("Worker thread is working...");
            Thread.Sleep(1000);
        }
    }
}

Sample Output:
Press any key to stop the worker thread...
Worker thread is working...
Worker thread is working...
... Worker thread stopped.

Explanation:
- Volatile Field: `_shouldStop` is marked as `volatile` to ensure visibility across threads.
- Worker Thread: Continuously checks `_shouldStop` to determine when to exit.
- Main Thread: Sets `_shouldStop` to `true` upon key press, signaling the worker thread to stop.

6.3 Interlocked Class

The `System.Threading.Interlocked` class provides atomic operations for variables that are shared by multiple threads, preventing race conditions without the need for explicit locks.

Example: Using Interlocked for Atomic Operations

using System;
using System.Threading;

class Program
{
    static int counter = 0;

    static void Main()
    {
        Thread t1 = new Thread(IncrementCounter);
        Thread t2 = new Thread(IncrementCounter);
        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
        Console.WriteLine($"Final Counter Value: {counter}");
    }

    static void IncrementCounter()
    {
        for(int i = 0; i < 100000; i++)
        {
            Interlocked.Increment(ref counter);
        }
    }
}

Sample Output:
Final Counter Value: 200000

Explanation:
- Interlocked.Increment: Atomically increments the `counter`, ensuring thread-safe operations without locks.
- Final Counter Value: Ensures that the `counter` is correctly incremented to `200000` despite concurrent access.

6.4 ReaderWriterLockSlim

`ReaderWriterLockSlim` allows multiple threads to read from a shared resource concurrently while ensuring exclusive access for write operations.

Example: Using ReaderWriterLockSlim for Synchronization

using System;
using System.Threading;

class Program
{
    static ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();
    static int sharedData = 0;

    static void Main()
    {
        Thread reader1 = new Thread(ReadData);
        Thread reader2 = new Thread(ReadData);
        Thread writer = new Thread(WriteData);

        reader1.Start();
        reader2.Start();
        writer.Start();

        reader1.Join();
        reader2.Join();
        writer.Join();
    }

    static void ReadData()
    {
        rwLock.EnterReadLock();
        try
        {
            Console.WriteLine($"Reader Thread {Thread.CurrentThread.ManagedThreadId}: Shared Data = {sharedData}");
        }
        finally
        {
            rwLock.ExitReadLock();
        }
    }

    static void WriteData()
    {
        rwLock.EnterWriteLock();
        try
        {
            sharedData = 42;
            Console.WriteLine($"Writer Thread {Thread.CurrentThread.ManagedThreadId}: Shared Data updated to {sharedData}");
        }
        finally
        {
            rwLock.ExitWriteLock();
        }
    }
}

Sample Output:
Reader Thread 3: Shared Data = 0
Reader Thread 4: Shared Data = 0
Writer Thread 5: Shared Data updated to 42

Explanation:
- EnterReadLock: Allows multiple reader threads to access the shared data concurrently.
- EnterWriteLock: Ensures exclusive access for writer threads, blocking readers until the write operation is complete.
- Shared Data: Protected by the `ReaderWriterLockSlim` to prevent inconsistent reads and writes.

7. Deadlocks

A deadlock occurs when two or more threads are waiting indefinitely for each other to release resources, causing the application to hang.

7.1 Example of Deadlock

using System;
using System.Threading;

class Program
{
    static readonly object lockA = new object();
    static readonly object lockB = new object();

    static void Main()
    {
        Thread t1 = new Thread(Thread1);
        Thread t2 = new Thread(Thread2);
        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
    }

    static void Thread1()
    {
        lock(lockA)
        {
            Console.WriteLine("Thread1 acquired lockA");
            Thread.Sleep(1000); // Simulate work
            lock(lockB)
            {
                Console.WriteLine("Thread1 acquired lockB");
            }
        }
    }

    static void Thread2()
    {
        lock(lockB)
        {
            Console.WriteLine("Thread2 acquired lockB");
            Thread.Sleep(1000); // Simulate work
            lock(lockA)
            {
                Console.WriteLine("Thread2 acquired lockA");
            }
        }
    }
}

Sample Output:
Thread1 acquired lockA
Thread2 acquired lockB
(Deadlock occurs here, no further output)

Explanation:
- Thread1: Acquires `lockA` and then attempts to acquire `lockB`.
- Thread2: Acquires `lockB` and then attempts to acquire `lockA`.
- Deadlock: Both threads hold one lock and wait indefinitely for the other, causing the application to hang.

7.2 Preventing Deadlocks

- Lock Ordering: Ensure that all threads acquire locks in the same order.
- Using Timeout with Locks: Use methods like `Monitor.TryEnter` with a timeout to prevent indefinite waiting.
- Minimize Lock Scope: Keep the locked section as small as possible to reduce contention.
- Avoid Nested Locks: Reduce the complexity of lock acquisition to minimize the chance of deadlocks.

Example: Using Lock Ordering to Prevent Deadlock

using System;
using System.Threading;

class Program
{
    static readonly object lockA = new object();
    static readonly object lockB = new object();

    static void Main()
    {
        Thread t1 = new Thread(Thread1);
        Thread t2 = new Thread(Thread2);
        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
    }

    static void Thread1()
    {
        lock(lockA)
        {
            Console.WriteLine("Thread1 acquired lockA");
            Thread.Sleep(1000); // Simulate work
            lock(lockB)
            {
                Console.WriteLine("Thread1 acquired lockB");
            }
        }
    }

    static void Thread2()
    {
        lock(lockA) // Acquires lockA first
        {
            Console.WriteLine("Thread2 acquired lockA");
            Thread.Sleep(1000); // Simulate work
            lock(lockB)
            {
                Console.WriteLine("Thread2 acquired lockB");
            }
        }
    }
}

Sample Output:
Thread1 acquired lockA
Thread2 acquired lockA
Thread1 acquired lockB
Thread2 acquired lockB

Explanation:
- Both threads acquire `lockA` before `lockB`, preventing circular wait and thereby avoiding deadlock.

8. Best Practices for Multithreading

- Avoid Shared State: Minimize the use of shared variables to reduce the complexity of synchronization.

- Use High-Level Constructs: Prefer using the Task Parallel Library (TPL), `async`/`await`, and concurrent collections over manual thread management.

- Implement Proper Synchronization: Use appropriate synchronization mechanisms like `lock`, `Monitor`, `SemaphoreSlim`, and `ReaderWriterLockSlim`.

- Handle Exceptions in Threads: Ensure that exceptions within threads are properly caught and handled to prevent unexpected application termination.

- Keep Thread Workloads Balanced: Distribute workloads evenly across threads to optimize performance.

- Use Immutable Objects: Favor immutable data structures to simplify thread safety.

- Limit the Number of Threads: Excessive threads can lead to context switching overhead and degrade performance. Use thread pools or TPL to manage threads efficiently.

- Avoid Blocking Calls: Prefer asynchronous programming to keep threads free to perform other tasks, enhancing scalability and responsiveness.

9. Advanced Topics

9.1 Parallel Programming Patterns

Task-Based Asynchronous Pattern (TAP): Uses `Task` and `async`/`await` for asynchronous operations, promoting a more manageable and readable code structure.

Example: Task-Based Asynchronous Pattern

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Console.WriteLine("Main thread starts.");
        await PerformAsyncOperation();
        Console.WriteLine("Main thread ends.");
    }

    static async Task PerformAsyncOperation()
    {
        Console.WriteLine("Async operation starts.");
        await Task.Delay(2000); // Simulate asynchronous work
        Console.WriteLine("Async operation ends.");
    }
}

Sample Output:
Main thread starts.
Async operation starts.
Async operation ends.
Main thread ends.

Explanation:
- Async/Await: Simplifies asynchronous programming by allowing code to be written in a synchronous style.
- Task.Delay: Simulates an asynchronous operation without blocking the main thread.

9.2 Cancellation Tokens

Cancellation tokens allow cooperative cancellation of asynchronous and long-running tasks, enabling graceful termination.

Example: Using CancellationToken to Cancel a Task

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        CancellationTokenSource cts = new CancellationTokenSource();
        Task longRunningTask = LongRunningOperation(cts.Token);

        Console.WriteLine("Press any key to cancel the operation...");
        Console.ReadKey();
        cts.Cancel();

        try
        {
            await longRunningTask;
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("Operation was canceled.");
        }
    }

    static async Task LongRunningOperation(CancellationToken token)
    {
        for(int i = 1; i <= 10; i++)
        {
            token.ThrowIfCancellationRequested();
            Console.WriteLine($"Operation step {i}");
            await Task.Delay(1000, token); // Simulate work
        }
    }
}

Sample Output:
Operation step 1
Operation step 2
...
(Operation canceled upon key press)

Explanation:
- CancellationTokenSource: Creates a token that can signal cancellation.
- ThrowIfCancellationRequested: Checks if cancellation has been requested and throws an `OperationCanceledException` if so.
- Task.Delay with Token: Allows the delay to be canceled if the token is signaled.
- Handling Cancellation: The `catch` block handles the cancellation exception, allowing for graceful termination.

9.3 Deadlock Detection and Prevention

Implement mechanisms to detect potential deadlocks and design the system to prevent them through careful synchronization strategies.

Example: Using Timeout to Prevent Deadlock

using System;
using System.Threading;

class Program
{
    static readonly object lockA = new object();
    static readonly object lockB = new object();

    static void Main()
    {
        Thread t1 = new Thread(Thread1);
        Thread t2 = new Thread(Thread2);
        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
    }

    static void Thread1()
    {
        if(Monitor.TryEnter(lockA, TimeSpan.FromSeconds(2)))
        {
            try
            {
                Console.WriteLine("Thread1 acquired lockA");
                Thread.Sleep(1000); // Simulate work
                if(Monitor.TryEnter(lockB, TimeSpan.FromSeconds(2)))
                {
                    try
                    {
                        Console.WriteLine("Thread1 acquired lockB");
                    }
                    finally
                    {
                        Monitor.Exit(lockB);
                    }
                }
                else
                {
                    Console.WriteLine("Thread1 could not acquire lockB");
                }
            }
            finally
            {
                Monitor.Exit(lockA);
            }
        }
        else
        {
            Console.WriteLine("Thread1 could not acquire lockA");
        }
    }

    static void Thread2()
    {
        if(Monitor.TryEnter(lockB, TimeSpan.FromSeconds(2)))
        {
            try
            {
                Console.WriteLine("Thread2 acquired lockB");
                Thread.Sleep(1000); // Simulate work
                if(Monitor.TryEnter(lockA, TimeSpan.FromSeconds(2)))
                {
                    try
                    {
                        Console.WriteLine("Thread2 acquired lockA");
                    }
                    finally
                    {
                        Monitor.Exit(lockA);
                    }
                }
                else
                {
                    Console.WriteLine("Thread2 could not acquire lockA");
                }
            }
            finally
            {
                Monitor.Exit(lockB);
            }
        }
        else
        {
            Console.WriteLine("Thread2 could not acquire lockB");
        }
    }
}

Sample Output:
Thread1 acquired lockA
Thread2 acquired lockB
Thread1 acquired lockB
Thread2 acquired lockA

Explanation:
- Monitor.TryEnter: Attempts to acquire a lock within a specified timeout, preventing indefinite waiting.
- Graceful Handling: If a lock cannot be acquired, the thread can perform alternative actions or retry, avoiding deadlock scenarios.

9.4 Concurrent Collections

The `System.Collections.Concurrent` namespace provides thread-safe collection classes that can be used safely by multiple threads concurrently without additional synchronization.

Example: Using ConcurrentBag for Thread-Safe Operations

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

class Program
{
    static void Main()
    {
        ConcurrentBag<int> bag = new ConcurrentBag<int>();
        Parallel.For(0, 1000, i =>
        {
            bag.Add(i);
        });

        Console.WriteLine($"Total items in ConcurrentBag: {bag.Count}");
    }
}

Sample Output:
Total items in ConcurrentBag: 1000

Explanation:
- ConcurrentBag: A thread-safe, unordered collection of items.
- Parallel.For: Adds items to the `ConcurrentBag` concurrently without requiring explicit locks.
- Count Property: Accurately reflects the number of items, ensuring thread safety.

9.5 Asynchronous Streams (C# 8.0 and Later)

Asynchronous streams allow asynchronous iteration over data sources, combining the benefits of asynchronous programming with streaming data.

Example: Using Async Streams to Process Data Asynchronously

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        await foreach(var number in GenerateNumbersAsync())
        {
            Console.WriteLine(number);
        }
    }

    static async IAsyncEnumerable<int> GenerateNumbersAsync()
    {
        for(int i = 1; i <= 5; i++)
        {
            await Task.Delay(500); // Simulate asynchronous work
            yield return i;
        }
    }
}

Sample Output:
1
2
3
4
5

Explanation:
- IAsyncEnumerable: Represents an asynchronous stream of data.
- Yield Return with Async: Allows each item to be returned asynchronously, enabling non-blocking iteration.

10. Real-World Example: Web Server Handling Multiple Requests

In web server applications, handling multiple client requests concurrently is essential for performance and responsiveness. Multithreading allows the server to process multiple requests in parallel, utilizing system resources efficiently.

Example: Simple Multithreaded HTTP Server

using System;
using System.Net;
using System.Text;
using System.Threading;

class Program
{
    static void Main()
    {
        HttpListener listener = new HttpListener();
        listener.Prefixes.Add("http://localhost:8080/");
        listener.Start();
        Console.WriteLine("HTTP Server started. Listening on http://localhost:8080/");

        while(true)
        {
            HttpListenerContext context = listener.GetContext(); // Blocking call
            ThreadPool.QueueUserWorkItem(o => HandleRequest(context));
        }
    }

    static void HandleRequest(HttpListenerContext context)
    {
        string responseString = "<html><body><h1>Hello from Multithreaded C# Server!</h1></body></html>";
        byte[] buffer = Encoding.UTF8.GetBytes(responseString);
        context.Response.ContentLength64 = buffer.Length;
        context.Response.OutputStream.Write(buffer, 0, buffer.Length);
        context.Response.OutputStream.Close();
        Console.WriteLine("Handled a request.");
    }
}

Instructions to Test:
1. Run the Server: Execute the above program. It starts an HTTP server listening on `http://localhost:8080/`.
2. Send Requests: Open multiple browser tabs and navigate to `http://localhost:8080/` to send requests.
3. Observe Output: The console will display "Handled a request." for each incoming request, demonstrating concurrent handling.

Explanation:
- HttpListener: Listens for HTTP requests.
- ThreadPool.QueueUserWorkItem: Handles each request on a thread pool thread, allowing multiple requests to be processed concurrently.
- Concurrency: Multiple clients can receive responses without waiting for others to complete, ensuring the server remains responsive.

11. Common Mistakes and How to Avoid Them

- Race Conditions:
Mistake:

using System;
using System.Threading;

class Program
{
  static int counter = 0;

  static void Main()
  {
      Thread t1 = new Thread(Increment);
      Thread t2 = new Thread(Increment);
      t1.Start();
      t2.Start();
      t1.Join();
      t2.Join();
      Console.WriteLine($"Final Counter: {counter}");
  }

  static void Increment()
  {
      for(int i = 0; i < 100000; i++)
      {
          counter++;
      }
  }
}

Issue:Increments to `counter` are not atomic, leading to an inconsistent final value.

Solution: Use synchronization mechanisms like `lock` or `Interlocked` to ensure thread-safe operations.
Corrected Example:

using System;
using System.Threading;

class Program
{
  static int counter = 0;
  static readonly object locker = new object();

  static void Main()
  {
      Thread t1 = new Thread(Increment);
      Thread t2 = new Thread(Increment);
      t1.Start();
      t2.Start();
      t1.Join();
      t2.Join();
      Console.WriteLine($"Final Counter: {counter}"); // Should reliably be 200000
  }

  static void Increment()
  {
      for(int i = 0; i < 100000; i++)
      {
          Interlocked.Increment(ref counter);
          // Alternatively:
          // lock(locker)
          // {
          //     counter++;
          // }
      }
  }
}

- Deadlocks:
Mistake: Acquiring multiple locks in different orders, leading to circular wait.
Solution: Always acquire locks in a consistent global order to prevent circular dependencies.

- Excessive Thread Creation:
Mistake: Creating too many threads can exhaust system resources and degrade performance.
Solution: Utilize thread pools (`ThreadPool`, `Task Parallel Library`) to manage threads efficiently.

- Ignoring Exceptions in Threads:
Mistake: Exceptions thrown in threads may go unnoticed, causing silent failures.
Solution: Implement proper exception handling within threads to catch and handle exceptions.

Example: Handling Exceptions in Tasks

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        try
        {
            await Task.Run(() => ThrowException());
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Caught exception: {ex.Message}");
        }
    }

    static void ThrowException()
    {
        throw new InvalidOperationException("An error occurred in the task.");
    }
}

Sample Output:
Caught exception: An error occurred in the task.

Explanation:
- Exception Handling: Exceptions thrown within a task are captured and can be awaited, allowing them to be caught in `try-catch` blocks surrounding the `await` expression.

12. Summary

Multithreading in C# is a robust feature that, when used correctly, can greatly enhance the performance and responsiveness of applications. By understanding the fundamentals of threads, synchronization mechanisms, and high-level abstractions like the Task Parallel Library, developers can build efficient and scalable applications.

Key Takeaways:
- Thread Management: Utilize the `Thread` class for basic thread management, and prefer the Task Parallel Library (`Task`, `Parallel`, `async`/`await`) for more advanced scenarios.

- Synchronization: Implement proper synchronization mechanisms (`lock`, `Monitor`, `SemaphoreSlim`, `ReaderWriterLockSlim`, `Interlocked`) to ensure thread safety and prevent race conditions.

- Avoid Deadlocks: Design synchronization strategies carefully to prevent deadlocks, such as consistent lock ordering and using timeouts.

- Thread Pooling: Leverage thread pools to manage system resources efficiently and avoid the overhead of excessive thread creation.

- Exception Handling: Properly handle exceptions within threads to prevent silent failures and ensure application stability.

- Immutable Objects: Favor immutable data structures to simplify thread safety.

- Concurrent Collections: Use thread-safe collections (`ConcurrentBag`, `ConcurrentDictionary`, etc.) to manage shared data without explicit synchronization.

- Best Practices: Follow best practices for multithreading, including minimizing shared state, keeping locks as short as possible, and using high-level abstractions for easier management.

By mastering these concepts and techniques, you can harness the full potential of multithreading in C#, creating applications that are both high-performing and reliable.