Parallelization Overview in C#

Parallelization Overview in C#

**Parallelization** in C# allows executing multiple tasks **simultaneously** to improve performance on **multi-core processors**. The **Task Parallel Library (TPL)** and **Parallel.For/Parallel.Invoke** help efficiently distribute workloads.

Key Features of Parallelization

• Utilizes **multiple CPU cores** for improved performance.
• Supports **automatic workload distribution** across threads.
• Uses **Task Parallel Library (TPL)** for high-level parallelism.
• Handles **loops, recursive methods, and independent tasks** efficiently.

Basic Parallel Execution

The **Parallel.Invoke()** method allows executing multiple tasks in parallel.

Example: Running Multiple Tasks in Parallel

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 runs **multiple independent tasks** concurrently.

Using Parallel.For for Loops

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

Example: Using Parallel.For for Faster Loop Execution

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 divides iterations **across multiple threads**.

Using Parallel.ForEach for Collections

The **Parallel.ForEach()** method **processes collection elements in parallel**.

Example: Using Parallel.ForEach to Process a List Faster

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 **large collections** by distributing work across CPU cores.

Parallel Execution vs Sequential Execution

Parallel execution speeds up processing by **splitting work across multiple CPU cores**, while sequential execution runs tasks **one after another**.

Best Practices for Parallelization

• Use **Parallel.Invoke()** for **independent tasks** that can run in parallel.
• Use **Parallel.ForEach()** for **processing collections efficiently**.
• Avoid parallelization for **small tasks** as it may introduce **overhead**.
• Ensure **thread safety** when modifying shared resources.