1. lock关键字

lock关键字是C#中最常用的一种锁，它基于Monitor类实现，用于对代码块进行加锁。lock关键字使用起来简单方便，适用于大多数情况下的线程同步。

public class Counter
{
    private int count = 0;
    private object lockObj = new object();

    public void Increment()
    {
        lock (lockObj)
        {
            count++;
        }
    }

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

2. Monitor类

Monitor类是一个轻量级的同步对象，提供了更灵活的线程同步机制。除了lock语句，我们也可以直接使用Monitor类中的方法进行线程同步。

public class Counter
{
    private int count = 0;
    private object lockObj = new object();

    public void Increment()
    {
        Monitor.Enter(lockObj);
        try
        {
            count++;
        }
        finally
        {
            Monitor.Exit(lockObj);
        }
    }

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

3. Mutex类

Mutex类是一种命名系统对象，用于跨进程的线程同步。它通常用于在多个进程之间共享资源的情况下进行同步。

public class SharedResource
{
    private static Mutex mutex = new Mutex();

    public void AccessResource()
    {
        mutex.WaitOne();
        try
        {
            // 访问共享资源的代码
        }
        finally
        {
            mutex.ReleaseMutex();
        }
    }
}

4. Semaphore类

Semaphore类是一种计数信号量，用于控制同时访问某个资源的线程数量。它允许多个线程同时访问共享资源，但需要控制并发的数量。

public class ResourceManager
{
    private static Semaphore semaphore = new Semaphore(5, 5); // 允许最多5个线程同时访问

    public void AccessResource()
    {
        semaphore.WaitOne();
        try
        {
            // 访问共享资源的代码
        }
        finally
        {
            semaphore.Release();
        }
    }
}

5. ReaderWriterLock类

ReaderWriterLock类是一种读写锁，允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。

public class SharedResource
{
    private ReaderWriterLock rwLock = new ReaderWriterLock();

    public void ReadResource()
    {
        rwLock.AcquireReaderLock(Timeout.Infinite);
        try
        {
            // 读取共享资源的代码
        }
        finally
        {
            rwLock.ReleaseReaderLock();
        }
    }

    public void WriteResource()
    {
        rwLock.AcquireWriterLock(Timeout.Infinite);
        try
        {
            // 写入共享资源的代码
        }
        finally
        {
            rwLock.ReleaseWriterLock();
        }
    }
}