浅谈C#之线程锁

一、基本介绍

        线程锁通常指的是lock关键字，它用于确保当一个线程位于代码的临界区时，其他线程不进入该区。lock通常用于保护共享资源，避免竞争条件。

二、关键点

锁（Lock）：lock关键字是C#中用于实现线程同步的最常用方法。它确保一个线程在执行代码块时，其他线程不能进入这个代码块。

private readonly object _lockObject = new object();

public void SomeMethod()
{
    lock (_lockObject)
    {
        // 受保护的代码
    }
}

Monitor：Monitor类提供了更灵活的锁定机制。它允许尝试进入锁定状态（TryEnter），设置超时（Wait），以及在不需要时释放锁（Pulse和Exit）。

private readonly object _lockObject = new object();

public void SomeMethod()
{
    Monitor.Enter(_lockObject);
    try
    {
        // 受保护的代码
    }
    finally
    {
        Monitor.Exit(_lockObject);
    }
}

Mutex：Mutex是一种跨进程的同步机制，它允许不同进程间的线程同步。在C#中，Mutex类提供了这种功能。

using System.Threading;

Mutex mutex = new Mutex();

public void SomeMethod()
{
    mutex.WaitOne();
    try
    {
        // 受保护的代码
    }
    finally
    {
        mutex.ReleaseMutex();
    }
}

Semaphore：Semaphore是一个计数信号量，它允许多个线程同时访问资源，但是限制了同时访问的最大线程数。

using System.Threading;

Semaphore semaphore = new Semaphore(3, 3);

public void SomeMethod()
{
    semaphore.WaitOne();
    try
    {
        // 受保护的代码
    }
    finally
    {
        semaphore.Release();
    }
}

ReaderWriterLockSlim：这是一种更轻量级的锁，专为读多写少的场景设计。它允许多个读操作并行执行，但写操作是独占的。

using System.Threading;

ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();

public void ReadMethod()
{
    rwLock.EnterReadLock();
    try
    {
        // 读取操作
    }
    finally
    {
        rwLock.ExitReadLock();
    }
}

public void WriteMethod()
{
    rwLock.EnterWriteLock();
    try
    {
        // 写入操作
    }
    finally
    {
        rwLock.ExitWriteLock();
    }
}

AsyncLock：在异步编程中，传统的锁机制可能不适用，因为它们不支持异步等待。AsyncLock是一个异步锁，它允许异步方法在等待锁时释放线程。

using System.Threading.Tasks;
using System.Threading;

public class AsyncLock
{
    private readonly object _lockObject = new object();
    private readonly Task<Releaser> _releaserTask = Task.FromResult(new Releaser(null));

    public async Task EnterAsync()
    {
        var releaser = await _releaserTask;
        lock (_lockObject)
        {
            releaser = await _releaserTask.ConfigureAwait(false);
        }
        await releaser.DisposeAsync();
    }

    private class Releaser : IDisposable
    {
        private readonly TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();

        public Releaser(TaskCompletionSource<bool> tcs)
        {
            _tcs = tcs;
        }

        public async Task DisposeAsync()
        {
            lock (_lockObject)
            {
                _releaserTask = _tcs.Task;
            }
            _tcs.TrySetResult(true);
        }
    }
}

三、注意事项

• 避免死锁：确保在代码中不会有两个或更多的线程相互等待对方释放锁。
• 避免资源争用：尽量减少锁的持有时间，以减少线程等待时间。
• 考虑性能：不同的锁机制有不同的性能特性，选择合适的锁机制可以提高程序性能。