Thread Synchronization in C#: From Basics to Advanced

Hello everyone! Today I want to talk with you about the thread synchronization mechanisms in C#. In multi-threaded programming, different threads may access shared resources simultaneously, which is like multiple people trying to grab a hamburger at the same time. If not managed properly, chaos can ensue. So, let’s learn how to elegantly handle these concurrent access issues!

Why Do We Need Thread Synchronization?

Imagine you and your roommate share a bathroom. If you don’t communicate in advance about who goes first, you might run into each other. In programming, it’s similar; when multiple threads access shared resources simultaneously, without synchronization control, it can lead to data inconsistency.

Take a look at the classic counter problem below:

public class Counter
{
    private int count = 0;
    public void Increment()
    {
        count++; // This operation is not atomic!
    }
    public int GetCount()
    {
        return count;
    }
}

If multiple threads call the <span>Increment()</span> method simultaneously, the final result may be surprising.

The lock Keyword: The Most Common Synchronization Mechanism

<span>lock</span> is the simplest and most commonly used synchronization mechanism in C#. It acts like a lock on resources, allowing only one thread to access them at a time.

public class SafeCounter
{
    private int count = 0;
    private readonly object _lock = new object();
    public void Increment()
    {
        lock (_lock)
        {
            count++;
        }
    }
    public int GetCount()
    {
        lock (_lock)
        {
            return count;
        }
    }
}

📌 Tip: Always declare the lock object as <span>private readonly</span>, to prevent external code from inadvertently interfering with the synchronization mechanism.

The Monitor Class: The Unsung Hero Behind lock

In fact, the <span>lock</span> keyword is syntactic sugar for the <span>Monitor</span> class. Using the <span>Monitor</span> class allows for more granular control:

public void ComplexOperation()
{
    var lockTaken = false;
    try
    {
        Monitor.Enter(_lock, ref lockTaken);
        // Perform synchronized operations
    }
    finally
    {
        if (lockTaken)
        {
            Monitor.Exit(_lock);
        }
    }
}

Mutex: The Choice for Inter-Process Synchronization

When synchronization is needed between different processes, we need to use a <span>Mutex</span>:

public class CrossProcessSync
{
    private static Mutex mutex = new Mutex(false, "Global\\MyUniqueMutexName");
    public void DoWork()
    {
        try
        {
            mutex.WaitOne();
            // Perform synchronized operations
        }
        finally
        {
            mutex.ReleaseMutex();
        }
    }
}

⚠️ Note: Using Mutex incurs additional system overhead; if you only need intra-process synchronization, prefer using <span>lock</span>.

Semaphore: Controlling the Number of Concurrent Accesses

Sometimes we need to limit the number of threads accessing a resource simultaneously, such as in a database connection pool:

public class ConnectionPool
{
    private SemaphoreSlim semaphore = new SemaphoreSlim(5); // Allow up to 5 concurrent connections
    public async Task UseConnectionAsync()
    {
        await semaphore.WaitAsync();
        try
        {
            // Use the database connection
            await Task.Delay(1000); // Simulate operation
        }
        finally
        {
            semaphore.Release();
        }
    }
}

ReaderWriterLockSlim: Improving Concurrency Efficiency

When read operations vastly outnumber write operations, using a reader-writer lock can significantly improve performance:

public class ThreadSafeCache<t>
{
    private Dictionary<string, t=""> _cache = new Dictionary<string, t="">();
    private ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
    public T GetValue(string key)
    {
        try
        {
            _lock.EnterReadLock();
            return _cache[key];
        }
        finally
        {
            _lock.ExitReadLock();
        }
    }
    public void SetValue(string key, T value)
    {
        try
        {
            _lock.EnterWriteLock();
            _cache[key] = value;
        }
        finally
        {
            _lock.ExitWriteLock();
        }
    }
}
</string,></string,></t>

💡 Performance Tip: If your application scenario involves more reads than writes, a reader-writer lock often provides better performance.

Synchronization in Asynchronous Programming

In modern .NET development, we often use async/await for asynchronous programming. Here, we can use <span>SemaphoreSlim</span> for asynchronous synchronization:

public class AsyncCounter
{
    private int count = 0;
    private SemaphoreSlim semaphore = new SemaphoreSlim(1);
    public async Task IncrementAsync()
    {
        await semaphore.WaitAsync();
        try
        {
            count++;
            await Task.Delay(100); // Simulate asynchronous operation
        }
        finally
        {
            semaphore.Release();
        }
    }
}

Friends, that’s all for today’s C# learning journey! Remember to write code and feel free to ask questions in the comments. Wish you all a happy learning experience, and may your C# development journey be ever brighter! Code changes the world, see you next time!