Parallel Extensions in C#

Parallel Extensions in C#

**Parallel Extensions** in C# provide a high-level abstraction for **parallel programming**, improving performance by distributing workloads across **multiple CPU cores**. The **System.Threading.Tasks.Parallel** class offers methods like **Parallel.For, Parallel.ForEach, and Parallel.Invoke** to execute tasks in parallel efficiently.

Key Features of Parallel Extensions

• Allows **automatic workload distribution** across multiple cores.
• Supports **parallel loops (Parallel.For, Parallel.ForEach)**.
• Efficiently runs **independent tasks** using **Parallel.Invoke**.
• Utilizes **task scheduling and thread pooling** for better performance.

Executing Multiple Actions with Parallel.Invoke

The **Parallel.Invoke()** method allows running multiple independent actions in parallel.

Example: Using Parallel.Invoke() for Parallel Execution

using System;
using System.Threading.Tasks;

class Program
{
    static void Task1() => Console.WriteLine($"Task 1 executed by {Task.CurrentId}");
    static void Task2() => Console.WriteLine($"Task 2 executed by {Task.CurrentId}");

    static void Main()
    {
        Parallel.Invoke(Task1, Task2);
        Console.WriteLine("Parallel tasks executed.");
    }
}

// Output:
// Task 1 executed by 1
// Task 2 executed by 2
// Parallel tasks executed.
        

The **Parallel.Invoke()** method executes multiple **independent tasks** in parallel.

Executing Loops in Parallel Using Parallel.For

The **Parallel.For()** method executes loop iterations in parallel across multiple CPU cores.

Example: Using Parallel.For() for Faster Iteration

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Parallel.For(1, 6, i =>
        {
            Console.WriteLine($"Iteration {i} executed by Task {Task.CurrentId}");
        });

        Console.WriteLine("Parallel loop completed.");
    }
}

// Output (order may vary):
// Iteration 1 executed by Task 1
// Iteration 2 executed by Task 2
// Iteration 3 executed by Task 3
// Iteration 4 executed by Task 4
// Iteration 5 executed by Task 5
// Parallel loop completed.
        

**Parallel.For()** automatically distributes iterations **across available CPU cores**.

Processing Collections in Parallel Using Parallel.ForEach

The **Parallel.ForEach()** method processes collection elements **in parallel**, improving performance for large data sets.

Example: Processing a List Using Parallel.ForEach()

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

class Program
{
    static void Main()
    {
        List<string> names = new List<string> { "Alice", "Bob", "Charlie", "David" };

        Parallel.ForEach(names, name =>
        {
            Console.WriteLine($"Processing {name} on Task {Task.CurrentId}");
        });

        Console.WriteLine("Parallel ForEach completed.");
    }
}

// Output (order may vary):
// Processing Alice on Task 1
// Processing Bob on Task 2
// Processing Charlie on Task 3
// Processing David on Task 4
// Parallel ForEach completed.
        

**Parallel.ForEach()** speeds up processing of **large collections** by utilizing multiple CPU cores.

Performance Considerations When Using Parallel Extensions

While parallel extensions improve performance, consider these best practices:

• Use **Parallel.For()** and **Parallel.ForEach()** for **CPU-bound tasks**.
• Avoid parallelism for **small tasks**, as the overhead may reduce performance.
• Ensure **thread safety** when modifying shared resources in **parallel loops**.
• Use **CancellationToken** to allow stopping parallel execution if necessary.

When to Use Parallel Extensions

• Use Parallel Extensions for **CPU-intensive** operations that can be divided into **independent tasks**.
• Avoid Parallel Extensions when working with **I/O-bound operations** (use **async/await** instead).
• Use **Parallel.ForEach()** for **batch processing** of large datasets.
• Ensure **workload is evenly distributed** to avoid **load imbalance across CPU cores**.