Concurrency and Parallel Programming in C#: a detailed hands-on exercise plan

#csharp #dotnet #programming #beginners

Here’s a detailed hands-on exercise plan for mastering Concurrency and Parallel Programming in C# (2025). Each phase includes concepts, code examples, and exercises to help you solidify your skills.

🚀 Phase 1: Fundamentals of Multithreading in C#

Concepts to Learn:

✔ Understanding Threads and how the Thread class works

✔ Managing Thread Lifecycle (Start, Sleep, Join, Abort)

✔ Thread Synchronization (lock, Monitor, Mutex, Semaphore, AutoResetEvent, ManualResetEvent)

✔ Avoiding Race Conditions & Deadlocks

Exercise 1: Creating a Simple Thread

📌 Task: Create a new thread that prints numbers from 1 to 10.

✅ Goal: Understand how to create and start a thread.

using System;
using System.Threading;

class Program
{
    static void PrintNumbers()
    {
        for (int i = 1; i <= 10; i++)
        {
            Console.WriteLine($"Thread: {i}");
            Thread.Sleep(500); // Simulate work
        }
    }

    static void Main()
    {
        Thread thread = new Thread(PrintNumbers);
        thread.Start();
        thread.Join(); // Wait for thread to finish
        Console.WriteLine("Main Thread Exiting...");
    }
}

Exercise 2: Thread Synchronization with `lock`

📌 Task: Create two threads that increment a shared counter.

✅ Goal: Prevent race conditions using lock.

using System;
using System.Threading;

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

    static void Increment()
    {
        for (int i = 0; i < 1000; i++)
        {
            lock (lockObject)  // Prevent race condition
            {
                counter++;
            }
        }
    }

    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}");
    }
}

Exercise 3: Avoiding Deadlocks

📌 Task: Simulate a deadlock and fix it using proper lock ordering.

✅ Goal: Learn deadlock prevention strategies.

using System;
using System.Threading;

class Program
{
    static object lock1 = new object();
    static object lock2 = new object();

    static void Thread1()
    {
        lock (lock1)
        {
            Thread.Sleep(100);
            lock (lock2)
            {
                Console.WriteLine("Thread1 acquired both locks.");
            }
        }
    }

    static void Thread2()
    {
        lock (lock2)
        {
            Thread.Sleep(100);
            lock (lock1)  // Reversed order causes deadlock
            {
                Console.WriteLine("Thread2 acquired both locks.");
            }
        }
    }

    static void Main()
    {
        Thread t1 = new Thread(Thread1);
        Thread t2 = new Thread(Thread2);

        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
    }
}

🔹 Fix: Ensure both threads lock objects in the same order.

🚀 Phase 2: Task-Based Asynchronous Programming (TAP)

Concepts to Learn:

✔ Understanding Task and Task.Run()

✔ Using ContinueWith() for task chaining

✔ Implementing Parallel.ForEach and Parallel.Invoke

Exercise 1: Running Tasks in Parallel

📌 Task: Run multiple tasks concurrently.

✅ Goal: Understand Task.Run().

using System;
using System.Threading.Tasks;

class Program
{
    static void TaskMethod()
    {
        Console.WriteLine($"Task Running on Thread {Task.CurrentId}");
    }

    static void Main()
    {
        Task t1 = Task.Run(TaskMethod);
        Task t2 = Task.Run(TaskMethod);
        Task.WaitAll(t1, t2);

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

Exercise 2: Using `Parallel.ForEach`

📌 Task: Process a list of numbers using Parallel.ForEach().

✅ Goal: Use PLINQ for faster processing.

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

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

        Parallel.ForEach(numbers, number =>
        {
            Console.WriteLine($"Processing {number} on thread {Task.CurrentId}");
        });

        Console.WriteLine("Processing complete.");
    }
}

🚀 Phase 3: Asynchronous Programming with async/await

Concepts to Learn:

✔ Async/Await Basics

✔ Task.Delay(), ConfigureAwait(false)

✔ Handling Exceptions in Async Methods

Exercise 1: Making an Async HTTP Request

📌 Task: Fetch data from an API asynchronously.

✅ Goal: Learn awaiting I/O-bound operations.

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task FetchDataAsync()
    {
        using HttpClient client = new HttpClient();
        string data = await client.GetStringAsync("https://jsonplaceholder.typicode.com/posts/1");
        Console.WriteLine(data);
    }

    static async Task Main()
    {
        await FetchDataAsync();
    }
}

Exercise 2: Async File Read

📌 Task: Read a file asynchronously.

✅ Goal: Learn I/O-bound async operations.

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

class Program
{
    static async Task ReadFileAsync(string path)
    {
        using StreamReader reader = new StreamReader(path);
        string content = await reader.ReadToEndAsync();
        Console.WriteLine(content);
    }

    static async Task Main()
    {
        await ReadFileAsync("test.txt");
    }
}

🚀 Phase 4: Data Parallelism & PLINQ

Exercise: Parallel LINQ (PLINQ)

📌 Task: Filter large datasets using PLINQ.

✅ Goal: Learn parallelized LINQ queries.

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        var numbers = Enumerable.Range(1, 100000);
        var evenNumbers = numbers.AsParallel().Where(n => n % 2 == 0).ToList();

        Console.WriteLine($"Total even numbers: {evenNumbers.Count}");
    }
}

🚀 Phase 5: Advanced Concurrency

Exercise: Producer-Consumer Pattern

📌 Task: Implement a producer-consumer pattern using BlockingCollection.

✅ Goal: Learn thread-safe queue processing.

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

class Program
{
    static BlockingCollection<int> queue = new BlockingCollection<int>();

    static void Producer()
    {
        for (int i = 0; i < 5; i++)
        {
            queue.Add(i);
            Console.WriteLine($"Produced: {i}");
            Thread.Sleep(100);
        }
        queue.CompleteAdding();
    }

    static void Consumer()
    {
        foreach (var item in queue.GetConsumingEnumerable())
        {
            Console.WriteLine($"Consumed: {item}");
        }
    }

    static void Main()
    {
        Task.Run(Producer);
        Task.Run(Consumer).Wait();
    }
}