Deadlock And Synchronization In C# Complete Guide

Example 1: Deadlock in C#

A deadlock occurs when two or more threads are blocked forever, each waiting for the other to release a resource.

Code:

using System;
using System.Threading;

class Program
{
    static readonly object lock1 = new object();
    static readonly object lock2 = new object();

    static void Thread1()
    {
        Console.WriteLine("Thread1 acquiring lock1");
        lock (lock1)
        {
            Console.WriteLine("Thread1 acquired lock1");
            Thread.Sleep(1000); // Simulate some work

            Console.WriteLine("Thread1 attempting to acquire lock2");
            lock (lock2)
            {
                Console.WriteLine("Thread1 acquired lock2");
            }
        }
    }

    static void Thread2()
    {
        Console.WriteLine("Thread2 acquiring lock2");
        lock (lock2)
        {
            Console.WriteLine("Thread2 acquired lock2");
            Thread.Sleep(1000); // Simulate some work

            Console.WriteLine("Thread2 attempting to acquire lock1");
            lock (lock1)
            {
                Console.WriteLine("Thread2 acquired lock1");
            }
        }
    }

    static void Main()
    {
        Thread t1 = new Thread(new ThreadStart(Thread1));
        Thread t2 = new Thread(new ThreadStart(Thread2));

        t1.Start();
        t2.Start();

        t1.Join();
        t2.Join();

        Console.WriteLine("Both threads have finished");
    }
}

Explanation:

1. Thread Initialization: We create two threads, Thread1 and Thread2.
2. Lock Acquisition: Thread1 acquires lock1 and then tries to acquire lock2. Simultaneously, Thread2 acquires lock2 and then tries to acquire lock1.
3. Deadlock Occurrence: Thread1 holds lock1 and waits for lock2, while Thread2 holds lock2 and waits for lock1. Both threads are blocked, and the program will not proceed.

Solution:

To prevent deadlocks, ensure that all threads acquire locks in a consistent order. For example, both threads should first attempt to lock lock1 and then lock2.

Example 2: Synchronization using Locks

The lock statement in C# is used to ensure that only one thread executes a block of code at a time.

Code:

using System;
using System.Threading;

class Counter
{
    private int count = 0;

    public object thisLock = new object();

    public void Increment()
    {
        lock (thisLock)
        {
            count++;
            Thread.Sleep(10); // Simulate some work
            Console.WriteLine($"Count is {count}");
        }
    }

    public int GetCount()
    {
        lock (thisLock)
        {
            return count;
        }
    }
}

class Program
{
    private static Counter counter = new Counter();

    static void ThreadMethod()
    {
        for (int i = 0; i < 100; i++)
        {
            counter.Increment();
        }
    }

    static void Main()
    {
        Thread t1 = new Thread(ThreadMethod);
        Thread t2 = new Thread(ThreadMethod);

        t1.Start();
        t2.Start();

        t1.Join();
        t2.Join();

        Console.WriteLine($"Final count is {counter.GetCount()}");
    }
}

Explanation:

1. Shared Counter: We have a Counter class that maintains a count and provides methods to increment and get the count.
2. Locking: The Increment and GetCount methods use lock (thisLock) to ensure that only one thread can modify or read the count at a time.
3. Thread Creation: We create two threads that each increment the count 100 times.
4. Result: Without the lock, the final count would be unpredictable due to race conditions. With the lock, the final count is guaranteed to be 200.

Example 3: Synchronization using Monitor

The Monitor class provides methods to enter and exit a lock on an object, similar to the lock statement.

Code:

using System;
using System.Threading;

class Counter
{
    private int count = 0;

    private readonly object thisLock = new object();

    public void Increment()
    {
        Monitor.Enter(thisLock);
        try
        {
            count++;
            Thread.Sleep(10); // Simulate some work
            Console.WriteLine($"Count is {count}");
        }
        finally
        {
            Monitor.Exit(thisLock);
        }
    }

    public int GetCount()
    {
        Monitor.Enter(thisLock);
        try
        {
            return count;
        }
        finally
        {
            Monitor.Exit(thisLock);
        }
    }
}

class Program
{
    private static Counter counter = new Counter();

    static void ThreadMethod()
    {
        for (int i = 0; i < 100; i++)
        {
            counter.Increment();
        }
    }

    static void Main()
    {
        Thread t1 = new Thread(ThreadMethod);
        Thread t2 = new Thread(ThreadMethod);

        t1.Start();
        t2.Start();

        t1.Join();
        t2.Join();

        Console.WriteLine($"Final count is {counter.GetCount()}");
    }
}

Explanation:

1. Counter Class: Similar to the previous example, we have a Counter class that maintains a count.
2. Monitor Usage: Instead of using the lock statement, we use Monitor.Enter and Monitor.Exit in a try-finally block to ensure that the lock is always released.
3. Thread Creation: We create two threads that each increment the count 100 times.
4. Result: The final count is correctly synchronized, ensuring that race conditions are avoided.

Example 4: Synchronization using Mutex

The Mutex class is a synchronization primitive that can be used across processes as well as threads.

Code:

using System;
using System.Threading;

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

    static void ThreadMethod(string name)
    {
        Console.WriteLine($"{name} waiting to enter the block");

        mutex.WaitOne(); // Request exclusive access

        try
        {
            Console.WriteLine($"{name} has entered the block");
            Thread.Sleep(1000); // Simulate some work
        }
        finally
        {
            Console.WriteLine($"{name} is leaving the block");
            mutex.ReleaseMutex(); // Release the lock
        }
    }

    static void Main()
    {
        Thread t1 = new Thread(() => ThreadMethod("Thread1"));
        Thread t2 = new Thread(() => ThreadMethod("Thread2"));

        t1.Start();
        t2.Start();

        t1.Join();
        t2.Join();

        Console.WriteLine("Both threads have finished");
    }
}

Explanation:

1. Mutex Initialization: We create a Mutex object that will be used to control access to a critical section of code.
2. Thread Creation: Two threads are created, each attempting to execute ThreadMethod.
3. Mutex Operation:
   • mutex.WaitOne(): This waits for the mutex to be in the signaled state (unlocked). If the mutex is not signaled, the thread is blocked.
   • mutex.ReleaseMutex(): This releases the mutex, allowing other threads to enter the critical section.
4. Result: Only one thread can execute the critical section at a time, preventing race conditions.

Key Points:

• Mutex vs. Lock: lock and Monitor are used for thread-level synchronization within a single process, while Mutex can be used for synchronization across multiple processes.
• Performance: lock and Monitor are generally more performant than Mutex for intra-process synchronization because they don't involve the system kernel.

Example 5: Synchronization using Semaphore

The Semaphore class allows multiple threads to access a resource, but limits the number of threads that can access the resource concurrently.

Code: