How ConcurrentDictionary works in .NET

In the world of multithreaded programming, ensuring thread safety while accessing shared resources is crucial. C# offers a variety of concurrent collections to make this task easier, and one of the most versatile among them is the ConcurrentDictionary.

What is ConcurrentDictionary?

ConcurrentDictionary is a thread-safe collection designed to be used in multi-threaded scenarios. Unlike the standard Dictionary<TKey, TValue>, which isn’t thread-safe, ConcurrentDictionary allows multiple threads to read and write without the need for external locking.

Initial Capacity

When initializing a ConcurrentDictionary, you can specify its initial capacity. This refers to the initial number of slots that the dictionary can hold. Specifying an initial capacity can be beneficial if you have an estimate of the number of items the dictionary will contain. This can help reduce the number of resizes, which can be expensive in terms of performance. The default initial capacity is 31 (a prime number). You can read more about how the initial capacity works in dictionaries in my other post here:
How Dictionary works in .NET – Coding Bolt

int initialCapacity = 11;
int concurrencyLevel = Environment.ProcessorCount * 2; // A common choice for concurrency level
var concurrentDictionary = new ConcurrentDictionary<int, string>(concurrencyLevel, initialCapacity);

Example: Caching Computed Results

Imagine you’re building a service that computes the factorial of numbers. Computing factorial can be time-consuming for large numbers. To optimize this, you can cache the results of previously computed factorials using a ConcurrentDictionary.

using System;
using System.Collections.Concurrent;

public class FactorialService
{
    private ConcurrentDictionary<int, long> _cache = new ConcurrentDictionary<int, long>();

    public long ComputeFactorial(int number)
    {
        if (number < 0)
        {
            throw new ArgumentException("Number should be non-negative.");
        }

        // If the result is already in the cache, return it.
        if (_cache.TryGetValue(number, out long cachedResult))
        {
            Console.WriteLine($"Cache hit for {number}!");
            return cachedResult;
        }

        // Compute the factorial.
        long result = 1;
        for (int i = 1; i <= number; i++)
        {
            result *= i;
        }

        // Cache the result.
        _cache[number] = result;

        return result;
    }
}

public class Program
{
    public static void Main()
    {
        var service = new FactorialService();

        Console.WriteLine(service.ComputeFactorial(5));  // Computes and caches the result.
        Console.WriteLine(service.ComputeFactorial(5));  // Uses cached result.
        Console.WriteLine(service.ComputeFactorial(7));  // Computes and caches the result.
    }
}

In this example:

We’ve created a FactorialService class that has a ConcurrentDictionary named _cache to store the results of previously computed factorials.
The ComputeFactorial method first checks if the result for the given number is already in the cache. If it is, it returns the cached result.
If the result isn’t in the cache, it computes the factorial, caches the result, and then returns it.

This approach ensures that the results of expensive computations are cached and reused, improving the performance of the service. Moreover, using ConcurrentDictionary ensures that the caching mechanism is thread-safe, allowing multiple threads to compute and cache results simultaneously without any issues.

Things to consider

Concurrency Overhead: ConcurrentDictionary is designed for thread safety. To achieve this, it employs fine-grained locking and other concurrency mechanisms. These mechanisms can introduce some overhead compared to the non-thread-safe Dictionary. In scenarios with high contention (many threads trying to access the dictionary simultaneously), this overhead might be noticeable.
Memory Overhead: ConcurrentDictionary might use more memory than a regular Dictionary due to its internal structures designed to handle concurrency.
Read-Heavy Scenarios: In scenarios where there are predominantly read operations with minimal writes, ConcurrentDictionary is optimized to perform very well. Reads can often occur entirely lock-free, making them very fast.
Bucket Resizing: Like any hash-based collection, the performance can degrade if there are too many collisions. However, ConcurrentDictionary handles resizing of its buckets to spread out the keys and reduce collisions. This resizing is thread-safe but can introduce some overhead during write operations when it occurs.

Conclusion

ConcurrentDictionary in C# is a powerful tool for multi-threaded applications, offering thread safety without sacrificing much on performance. While it has its nuances, when used correctly, it can greatly simplify concurrent programming challenges.

Coding Bolt