Understanding Threading and Tasks

Understanding Threading and Tasks

Welcome to the next lesson! In this lesson, you’ll learn about threading and tasks in C#, which allow you to execute multiple operations concurrently for better performance. Let’s get started!

Threading is the process of executing multiple operations simultaneously. Each thread represents a separate flow of control in your application.

Key Point: Threading improves performance by utilizing multiple processor cores for concurrent execution.

You can create and start threads using the Thread class. Example:

using System;
using System.Threading;

class Program {
    static void Main() {
        Thread thread = new Thread(PrintNumbers);
        thread.Start();

        Console.WriteLine("Main thread is running...");
    }

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

Tasks provide a higher-level abstraction for concurrent programming compared to threads. The Task class is part of the Task Parallel Library (TPL) in C#.

Example: Creating and starting a task:

Tip: Tasks are easier to manage and provide better error handling compared to threads.

using System;
using System.Threading.Tasks;

class Program {
    static void Main() {
        Task task = Task.Run(() => {
            for (int i = 1; i <= 5; i++) {
                Console.WriteLine(i);
                Task.Delay(1000).Wait();
            }
        });

        Console.WriteLine("Main thread is running...");
        task.Wait(); // Wait for the task to complete
    }
}

The Parallel class in C# allows you to execute loops in parallel for better performance. Example:

Key Point: Use Parallel.For and Parallel.ForEach for data-intensive tasks that can be executed concurrently.

using System;
using System.Threading.Tasks;

class Program {
    static void Main() {
        Parallel.For(0, 5, i => {
            Console.WriteLine($"Processing {i} on thread {Task.CurrentId}");
        });

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

You can catch exceptions in tasks using a try-catch block or the Task.Exception property. Example:

using System;
using System.Threading.Tasks;

class Program {
    static void Main() {
        try {
            Task task = Task.Run(() => {
                throw new InvalidOperationException("Task failed!");
            });

            task.Wait();
        } catch (AggregateException ex) {
            Console.WriteLine("Error: " + ex.InnerException.Message);
        }
    }
}

Create a program that starts multiple tasks to process numbers in parallel and prints their squares. Example:

using System;
using System.Threading.Tasks;

class Program {
    static void Main() {
        int[] numbers = { 1, 2, 3, 4, 5 };

        Parallel.ForEach(numbers, number => {
            Console.WriteLine($"Square of {number}: {number * number}");
        });
    }
}

Here are some best practices:

• Prefer Task over Thread for high-level concurrency.
• Use Parallel classes for data-intensive operations.
• Handle exceptions properly to ensure robust applications.
• Limit the number of threads or tasks to avoid resource contention.

Tip: Use async programming when I/O operations dominate, and use threads/tasks for CPU-bound tasks.

Congratulations! You’ve learned the basics of threading and tasks for concurrent programming in C#. In the next lesson, we’ll dive into delegates and lambda expressions, two powerful features for functional programming. Let’s keep coding!