Difference Between Concurrency and Parallelism in C#

Introduction

In modern software development, efficient resource utilization is crucial for delivering high-quality applications that can handle complex tasks and large amounts of data. One of the ways to achieve this is by leveraging the power of concurrency and parallelism, two concepts that are often used interchangeably but have distinct meanings and implications.

In this article, we will explore the difference between concurrency and parallelism, and how they are relevant for C# programming. We will also look at some examples of concurrency and parallelism in C#, and discuss the best practices and considerations for implementing them effectively.

What is Concurrency?

Concurrency is a condition that exists when at least two tasks can start, run, and complete in overlapping time periods. It doesn't necessarily mean that they will ever both be running at the same instant. For example, multitasking on a single-core machine is a form of concurrency, where the processor switches between tasks at a very fast rate, creating the illusion of parallelism.

Advantages of Concurrency

Improving the responsiveness and interactivity of the application by allowing tasks to run in the background without blocking the user interface.
Increasing the throughput and scalability of the application by allowing tasks to run concurrently on multiple processors or cores.
Simplifying the design and logic of the application by separating tasks into independent units that can communicate and coordinate with each other.

Some examples of concurrency in C#

Using the async and await keywords to write asynchronous code that can run in the background without blocking the main thread.
Using the Task class and the Task Parallel Library (TPL) to create and manage multiple tasks that can run concurrently on different threads.
Using the Concurrent namespace to access thread-safe collections and data structures that can handle concurrent access and modification.

Note. For more information on Concurrent collections, please take a look at my article on ConcurrentQueue in C#.

Concurrency is valuable in scenarios where:

The application needs to perform multiple tasks that are independent of each other and can run in any order.
The application needs to perform tasks that are dependent on external resources or events, such as network requests, user input, or timers.
The application needs to perform tasks that are computationally intensive and can benefit from parallel execution on multiple processors or cores.

What is Parallelism?

Parallelism is a condition that arises when at least two tasks are executing simultaneously. It means that they are literally running at the same time, e.g., on a multicore processor or a distributed system. Parallelism is a subset of concurrency, and it is achieved by using concurrency techniques.

Advantages of Parallelism

Improving the performance and efficiency of the application by utilizing the full potential of the hardware resources.
Reducing the execution time and latency of the application by dividing tasks into smaller subtasks that can run in parallel.
Enhancing the functionality and quality of the application by enabling complex and sophisticated computations and algorithms.

Some examples of parallelism in C#

Using the Parallel class and its methods, such as Parallel.ForEach and Parallel.For, to execute loops in parallel on multiple threads.
Using the PLINQ (Parallel Language Integrated Query) library to perform parallel queries on collections and data sources.
Using the System.Numerics namespace to access vector and matrix types and operations that can leverage hardware acceleration and parallel processing.

Parallelism is beneficial in scenarios where

The application needs to perform tasks that are independent of each other and can run in any order, but have a high computational cost and a low communication cost.
The application needs to perform tasks that are data-intensive and can be easily partitioned and aggregated.
The application needs to perform tasks that are embarrassingly parallel, meaning that they require little or no coordination or synchronization between them.

Key Differences between Concurrency and Parallelism

Based on the definitions and examples of concurrency and parallelism, we can summarize the key differences between them as follows:

Concurrency is a condition that exists when at least two tasks can start, run, and complete in overlapping time periods, while parallelism is a condition that arises when at least two tasks are executing simultaneously.
Concurrency is a more generalized form of parallelism that can include time-slicing as a form of virtual parallelism, while parallelism is a specific form of concurrency that requires simultaneous execution.
Concurrency is more about the design and structure of the application, while parallelism is more about the execution and performance of the application.
Concurrency can be achieved by using a single processing unit, while parallelism requires multiple processing units.
Concurrency aims to improve the responsiveness and interactivity of the application, while parallelism aims to improve the speed and efficiency of the application.

Concurrency and Parallelism in C

C# is a powerful and versatile programming language that supports both concurrency and parallelism. C# offers various features and libraries that enable developers to write concurrent and parallel code easily and effectively.

Some of the C# features and libraries for concurrency

The async and await keywords, which allow developers to write asynchronous code that can run in the background without blocking the main thread. Asynchronous code can improve the responsiveness and interactivity of the application, especially for tasks that depend on external resources or events. For example, the following code snippet shows how to use async and await to download a file from the internet and display its content on a text box:

private async void DownloadFileButton_Click(object sender, EventArgs e)
{
    // Create a web client
    using (var httpClient = new HttpClient())
    {
        // Download the file asynchronously
        var fileContent = await httpClient.GetStringAsync("https://example.com/file.txt");

        // Display the file content on the text box
        FileContentTextBox.Text = fileContent;
    }
}

The Task class and the Task Parallel Library (TPL), which allow developers to create and manage multiple tasks that can run concurrently on different threads. Tasks are units of work that can be executed asynchronously and can return a result or an exception. The TPL provides various methods and tools to create, run, cancel, wait, and handle tasks. For example, the following code snippet shows how to use the Task class and the TPL to calculate the sum of the squares of the numbers from 1 to 100:

private async void CalculateSumButton_Click(object sender, EventArgs e)
{
    // Create a task to calculate the sum of the squares
    var sumTask = Task.Run(() =>
    {
        // Initialize the sum variable
        var sum = 0;

        // Loop through the numbers from 1 to 100
        for (var i = 1; i <= 100; i++)
        {
            // Add the square of the number to the sum
            sum += i * i;
        }

        // Return the sum
        return sum;
    });

    // Wait for the task to complete and get the result
    var sumResult = await sumTask;

    // Display the result on the label
    SumResultLabel.Text = $"The sum of the squares is {sumResult}";
}

The Concurrent namespace, which provides thread-safe collections and data structures that can handle concurrent access and modification. Thread-safe collections and data structures are designed to prevent data corruption and inconsistency when multiple threads are operating on them simultaneously. For example, the following code snippet shows how to use the ConcurrentDictionary class to store and retrieve key-value pairs in a thread-safe manner:

// Create a concurrent dictionary
var dictionary = new ConcurrentDictionary<string, int>();

// Add some key-value pairs to the dictionary
dictionary.TryAdd("Apple", 5);
dictionary.TryAdd("Banana", 3);
dictionary.TryAdd("Orange", 4);

// Update the value of a key in the dictionary
dictionary.AddOrUpdate("Apple", 6, (key, oldValue) => oldValue + 1);

// Get the value of a key from the dictionary
var appleCount = dictionary["Apple"];

// Remove a key-value pair from the dictionary
dictionary.TryRemove("Banana", out var bananaCount);

Some of the C# features and libraries for parallelism

The Parallel class and its methods, such as Parallel.ForEach and Parallel.For, which allow developers to execute loops in parallel on multiple threads. Parallel loops can improve the performance and efficiency of the application, especially for tasks that are independent of each other and have a high computational cost. For example, the following code snippet shows how to use the Parallel.ForEach method to resize a list of images in parallel:

// Create a list of images
var images = new List<Image>();

// Populate the list with some images
images.Add(Image.FromFile("image1.jpg"));
images.Add(Image.FromFile("image2.jpg"));
images.Add(Image.FromFile("image3.jpg"));

// Create a list of resized images
var resizedImages = new ConcurrentBag<Image>();

// Resize the images in parallel using Parallel.ForEach
Parallel.ForEach(images, image =>
{
    // Resize the image to 100x100 pixels
    var resizedImage = ResizeImage(image, 100, 100);

    // Add the resized image to the concurrent bag
    resizedImages.Add(resizedImage);
});

The PLINQ (Parallel Language Integrated Query) library, which allows developers to perform parallel queries on collections and data sources. PLINQ can improve the performance and efficiency of the application, especially for tasks that are data-intensive and can be easily partitioned and aggregated. For example, the following code snippet shows how to use the AsParallel and ParallelEnumerable methods to calculate the average age of a list of persons in parallel:

// Create a list of persons
var persons = new List<Person>();

// Populate the list with some persons
persons.Add(new Person("Alice", 25));
persons.Add(new Person("Bob", 30));
persons.Add(new Person("Charlie", 35));
persons.Add(new Person("David", 40));

// Calculate the average age of the persons in parallel using PLINQ
var averageAge = persons.AsParallel().Average(person => person.Age);

The System.Numerics namespace, which provides vector and matrix types and operations that can leverage hardware acceleration and parallel processing. Vector and matrix types and operations can improve the performance and efficiency of the application, especially for tasks that involve complex and sophisticated computations and algorithms. For example, the following code snippet shows how to use the Vector2 and Matrix3x2 types and operations to perform a linear transformation on a set of points in parallel:

// Create an array of points
var points = new Vector2[4];

// Populate the array with some points
points[0] = new Vector2(1, 1);
points[1] = new Vector2(2, 2);
points[2] = new Vector2(3, 3);
points[3] = new Vector2(4, 4);

// Create a matrix that represents a linear transformation
var matrix = Matrix3x2.CreateRotation((float)Math.PI / 4) * Matrix3x2.CreateScale(2);

// Transform the points in parallel using the matrix
var transformedPoints = points.AsParallel().Select(point => Vector2.Transform(point, matrix)).ToArray();

Best Practices and Considerations

Concurrency and parallelism are powerful techniques that can enhance the functionality and quality of the application, but they also come with some challenges and complexities that require careful attention and planning. Here are some tips and considerations for managing concurrency and parallelism effectively.

When using concurrency, avoid race conditions, which occur when multiple threads access and modify the same shared resource without proper synchronization. Race conditions can lead to data corruption and inconsistency, and can be hard to detect and debug. To prevent race conditions, use thread-safe collections and data structures, such as those in the Concurrent namespace, or use synchronization mechanisms, such as locks, mutexes, semaphores, or monitors, to ensure that only one thread can access the shared resource at a time.
When using parallelism, consider the data partitioning and load balancing strategies, which determine how the data is divided and distributed among the threads. Data partitioning and load balancing can affect the performance and efficiency of the parallel execution, and should be chosen based on the characteristics and requirements of the data and the tasks. For example, use range partitioning for data that is ordered and homogeneous, and use hash partitioning for data that is unordered and heterogeneous. Use static load balancing for tasks that have a predictable and uniform workload, and use dynamic load balancing for tasks that have a variable and uneven workload.
When using both concurrency and parallelism, be aware of the synchronization and coordination issues, which arise when multiple threads need to communicate and cooperate with each other. Synchronization and coordination can affect the performance and efficiency of the concurrent and parallel execution, and should be minimized as much as possible. For example, use asynchronous methods and callbacks to avoid blocking and waiting for other threads, and use concurrent and parallel constructs and libraries, such as async/await, Task, Parallel, and PLINQ, to handle synchronization and coordination automatically and transparently.

Conclusion

In this article, we have learned the difference between concurrency and parallelism, and how they are relevant for C# programming. We have also looked at some examples of concurrency and parallelism in C#, and discussed the best practices and considerations for implementing them effectively.

Concurrency and parallelism are important concepts that can help developers write applications that can handle complex tasks and large amounts of data efficiently and effectively. By choosing the right approach for specific scenarios, developers can harness the power of concurrency and parallelism in C# for improved software performance and responsiveness.