Using Locks in C#

Understanding Locks in C#

**Locks** in C# are used to prevent **race conditions** when multiple threads access shared resources simultaneously. The `lock` statement, `Monitor`, `Mutex`, `Semaphore`, and `ReaderWriterLock` are commonly used synchronization mechanisms.

Key Features of Locks

Ensures **thread safety** when accessing shared data.
Prevents **race conditions** by allowing only one thread at a time.
Different types of locks are available based on requirements (`lock`, `Monitor`, `Mutex`, `Semaphore`).
May cause **deadlocks** if not used properly.

Using the Lock Statement

The `lock` statement provides a simple way to **synchronize access** to shared resources.

Example: Using `lock` for Thread Synchronization

using System;
using System.Threading;

class Program
{
    static readonly object _lock = new object();
    static int counter = 0;

    static void IncrementCounter()
    {
        for (int i = 0; i < 5; i++)
        {
            lock (_lock)
            {
                counter++;
                Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId}: Counter = {counter}");
            }
            Thread.Sleep(500);
        }
    }

    static void Main()
    {
        Thread thread1 = new Thread(IncrementCounter);
        Thread thread2 = new Thread(IncrementCounter);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();

        Console.WriteLine("Final Counter Value: " + counter);
    }
}

// Output (Ensures safe counter increment):
// Thread 1: Counter = 1
// Thread 2: Counter = 2
// Thread 1: Counter = 3
// Thread 2: Counter = 4
// Final Counter Value: 10

The **lock (_lock)** statement ensures that only **one thread** can modify `counter` at a time.

Using the Monitor Class

The `Monitor` class provides **more control** over locking than the `lock` statement.

Example: Using Monitor for Thread Synchronization

using System;
using System.Threading;

class Program
{
    static readonly object _lock = new object();
    static int counter = 0;

    static void IncrementCounter()
    {
        for (int i = 0; i < 5; i++)
        {
            bool lockTaken = false;
            try
            {
                Monitor.Enter(_lock, ref lockTaken);
                counter++;
                Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId}: Counter = {counter}");
            }
            finally
            {
                if (lockTaken) Monitor.Exit(_lock);
            }
            Thread.Sleep(500);
        }
    }

    static void Main()
    {
        Thread thread1 = new Thread(IncrementCounter);
        Thread thread2 = new Thread(IncrementCounter);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();

        Console.WriteLine("Final Counter Value: " + counter);
    }
}

// Output (Ensures safe counter increment):
// Thread 1: Counter = 1
// Thread 2: Counter = 2
// Final Counter Value: 10

`Monitor.Enter` provides **fine-grained control** over locking, allowing explicit unlocking in a `finally` block.

Using Mutex for Process Synchronization

`Mutex` allows **cross-process synchronization**, ensuring only one process can access a resource at a time.

Example: Using Mutex for Synchronization

using System;
using System.Threading;

class Program
{
    static Mutex mutex = new Mutex();

    static void AccessResource()
    {
        mutex.WaitOne(); // Acquire the lock
        Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} is accessing the resource.");
        Thread.Sleep(2000);
        Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} released the resource.");
        mutex.ReleaseMutex(); // Release the lock
    }

    static void Main()
    {
        Thread thread1 = new Thread(AccessResource);
        Thread thread2 = new Thread(AccessResource);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();
    }
}

// Output (Ensures only one thread accesses the resource at a time):
// Thread 1 is accessing the resource.
// (Waits for 2 seconds)
// Thread 1 released the resource.
// Thread 2 is accessing the resource.
// Thread 2 released the resource.

**Mutex.WaitOne()** blocks other threads until the lock is released using **Mutex.ReleaseMutex()**.

Best Practices for Using Locks

Use **lock** for **simple, single-threaded synchronization**.
Use **Monitor** for **fine-grained locking control** with `try-finally`.
Use **Mutex** when **synchronizing across multiple processes**.
Minimize **lock duration** to reduce **performance overhead**.
Avoid **nested locks**, as they can lead to **deadlocks**.

Previous: Async & Await