C# Lock vs Mutex: Understanding the Differences

Last updated on February 26th, 2024 at 09:50 am

In this article, we will explore the differences between C# Lock and Mutex classes and understand when to use each of them.

Problem Statement

Consider a multi-threaded application where multiple threads need to access a critical section of code that modifies a shared resource. How can we ensure that only one thread at a time can execute that section without causing data corruption or race conditions?

To avoid such issues, synchronization techniques are used to coordinate thread access. Two commonly used synchronization mechanisms in C# are the lock statement and the Mutex class. 

C# lock and Mutex are both essential tools for synchronizing threads and protecting shared resources. A lock is limited to a particular AppDomain, whereas a Mutex operates at the level of the Operating System, enabling inter-process locking and synchronization (IPC).

C# lock:

The lock statement is a simple and lightweight synchronization mechanism provided by C#. It ensures that only one thread can enter a specific code section at a time. The lock statement takes an object as a parameter, and this object is used to define the lock scope.

Here is the basic syntax of lock.

lock (lockObject)
{
    // Code to be executed exclusively by one thread at a time
}

Example: C# Lock Statement

Below is a C# code example that demonstrates the use of Lock statement.

using System;
using System.Threading;

class Program
{
    static int sharedValue = 0;
    static object lockObject = new object();

    static void IncrementSharedValue()
    {
        // Using the lock statement to ensure exclusive access to sharedValue
        lock (lockObject)
        {
            // Inside the lock block, only one thread can access this code at a time
            // This ensures thread-safety when multiple threads try to increment sharedValue simultaneously
            sharedValue++;
        }
    }

    static void Main()
    {
        const int numThreads = 4;
        Thread[] threads = new Thread[numThreads];

        for (int i = 0; i < numThreads; i++)
        {
            threads[i] = new Thread(() =>
            {
                // Each thread will call IncrementSharedValue method 5000 times
                for (int j = 0; j < 5000; j++)
                {
                    IncrementSharedValue();
                }
            });

            threads[i].Start();
        }

        // Wait for all threads to complete
        for (int i = 0; i < numThreads; i++)
        {
            threads[i].Join();
        }

        // The final value of sharedValue will depend on the number of threads and the number of increments
        Console.WriteLine("Final Shared Value: " + sharedValue);
        
    }
}

Output:

Final Shared Value: 20000

C# Mutex:

Mutex is another synchronization mechanism in C#. Unlike lock, which is limited to a single process, Mutex can be used for inter-process synchronization. It allows multiple threads from different processes to synchronize access to shared resources. 

The Mutex class uses the WaitHandle.WaitOne method to lock and the ReleaseMutex method to unlock. When a Mutex is closed or disposed, it is automatically released. Also, remember that you can only release a Mutex from the same thread that originally locked it.

Here is how you can use Mutex:

using System.Threading;

Mutex mutex = new Mutex();

void SomeMethod()
{
    mutex.WaitOne(); // Waits until the mutex is available
    try
    {
        // Code to be executed exclusively
    }
    finally
    {
        mutex.ReleaseMutex(); // Release the mutex
    }
}

C# Lock Vs Mutex

Here’s a detailed comparison table summarizing the differences between C# lock and Mutex:

Example: C# Mutex

Below is a C# code example that demonstrates the use of Mutex.

using System;
using System.Threading;

class Program
{
    // Mutex to synchronize access to the shared resource
    static Mutex mutex = new Mutex();

    // Shared resource to be accessed by multiple threads
    static int sharedResource = 0;

    // Method that increments the shared resource in a thread-safe manner
    static void IncrementSharedResource()
    {
        try
        {
            // Attempt to acquire the mutex before accessing the shared resource
            mutex.WaitOne();

            // Inside this block, only one thread can execute at a time

            // Simulate some work being done by the thread (e.g., updating a shared resource)
            int currentValue = sharedResource;
            Thread.Sleep(100); // Simulate some processing time
            sharedResource = currentValue + 1;
        }
        finally
        {
            // Ensure the mutex is released, even if an exception occurs
            mutex.ReleaseMutex();
        }
    }

    static void Main()
    {
        // Create two threads that will increment the shared resource
        Thread thread1 = new Thread(IncrementSharedResource);
        Thread thread2 = new Thread(IncrementSharedResource);

        // Start the threads
        thread1.Start();
        thread2.Start();

        // Wait for both threads to complete
        thread1.Join();
        thread2.Join();

        // The shared resource should be incremented twice (once by each thread)
        Console.WriteLine("Final value of the shared resource: " + sharedResource);
      
    }
}

Output:

  Final value of the shared resource: 2

FAQs: C# Lock vs. Mutex

Recommended Articles:

• Lock keyword in C# with examples
• C# Monitor class with Examples
• Understanding Class vs Struct vs Record in C# with examples
• Difference Between if-else and switch: A Side-by-Side Comparison of If-Else and Switch Case
• Singleton Design Pattern in C#: A Beginner’s Guide with Examples
• SOLID Design Principles in C#: A Complete Example
• C# Struct vs Class |Top 15+ Differences Between C# Struct and Class
• 10 Difference between interface and abstract class In C#
• C# Hashtable vs Dictionary
• C# Nullable types: How do you work with nullable types in C#?
• What is Web API? Everything You Need to Learn

• Author
• Recent Posts

Shekh Ali

Meet Sheikh Ali, a skilled Software engineer and passionate a blogger. He enjoys sharing his expertise in C#, Java, SQL, Design Patterns, and other related topics through his writing. When he's not coding, Sheikh Ali can often indulge in his passions for reading books and fitness training.

Latest posts by Shekh Ali (see all)

• C# Program to Capitalize the First Character of Each Word in a String - February 21, 2024
• C# Program to Find the Longest Word in a String - February 19, 2024
• How to Reverse an Array in C# with Examples - February 12, 2024