Multithreading and Async Programming in C#

# CHAPTER 24

Multithreading and Async Programming #

1. Introduction #

2. Learning Objectives #

• Understand the difference between Synchronous and Asynchronous execution.

• Use the Task Parallel Library (Task).

• Master the async and await keywords.

• Prevent application freezing.

3. The Problem: Synchronous Execution #

using System.Threading;

void DownloadFile()
{
    Console.WriteLine("Downloading...");
    Thread.Sleep(5000); // Simulates a 5-second freeze!
    Console.WriteLine("Done!");
}

Console.WriteLine("Start");
DownloadFile(); // The program COMPLETELY FREEZES here for 5 seconds.
Console.WriteLine("End");

4. The Solution: Task and async/await #

using System;
using System.Threading.Tasks;

class Program
{
    // The method MUST be marked 'async' and return a 'Task'
    static async Task DownloadFileAsync()
    {
        Console.WriteLine("Download started...");
        
        // await tells the compiler: "Go do this in the background. 
        // I will pause this specific method, but let the rest of the application keep running!"
        await Task.Delay(5000); // The async version of Thread.Sleep
        
        Console.WriteLine("Download finished!");
    }

    // Main can also be async in modern C#!
    static async Task Main()
    {
        Console.WriteLine("UI is running...");
        
        // Start the background task
        Task myTask = DownloadFileAsync();
        
        Console.WriteLine("UI is still responsive while downloading!");
        
        // Wait here until the background task finishes before exiting the program
        await myTask; 
        
        Console.WriteLine("Program complete.");
    }
}

5. Returning Data from Async Methods #

static async Task<int> FetchDataFromDatabaseAsync()
{
    await Task.Delay(2000); // Simulate network delay
    return 42; // Data fetched!
}

static async Task Main()
{
    // 'await' unwraps the Task<int> and gives you the actual integer!
    int data = await FetchDataFromDatabaseAsync();
    Console.WriteLine($"Received: {data}");
}

6. Threads vs. Tasks #

• Thread (Legacy): A low-level OS thread. Heavy to create. Managing them manually (locking, deadlocks) is extremely difficult.

• Task (Modern): A higher-level abstraction. The .NET Thread Pool manages tasks automatically, assigning them to available threads efficiently. Always use Tasks in modern C#.

7. Concurrency vs Parallelism #

• Concurrency (async/await): The program juggles multiple tasks. While waiting for a network response, the thread goes and updates the UI instead of sitting idle.

• Parallelism (Parallel.ForEach): The program explicitly uses multiple CPU cores to do complex math equations at the exact same time.

8. Common Mistakes #

• async void: NEVER write async void MethodName() unless it is an Event Handler (like a button click). If an async void method throws an exception, it crashes the entire application. Always use async Task.

• Forgetting await: If you call an async method but forget the await keyword, the method will start running, but the code will immediately move to the next line without waiting for the result. This causes unpredictable bugs.

9. Best Practices #

• Append the word Async to the name of any method that returns a Task (e.g., SaveToDbAsync()). This is a Microsoft standard convention.

• Use await all the way down the call stack. Do not mix synchronous blocking (.Result or .Wait()) with async code, as this causes Deadlocks.

10. Exercises #

1. 1. Write an async method BoilWaterAsync() that waits for 3 seconds.

1. 2. In Main, start BoilWaterAsync(), print "Chopping vegetables...", and then await the water.

11. MCQs with Answers #

12. Interview Questions #

• Q: Explain what async/await does under the hood (State Machine).

• Q: Why is async void considered dangerous?

• Q: Explain the difference between CPU-bound work (Parallelism) and I/O-bound work (Concurrency). Which is async/await better suited for?

13. Summary #

14. Next Chapter Recommendation #