当前位置：首页 > news >正文

C#中多线程访问对象锁问题的总结及解决方案

news 来源：原创 2025/5/6 13:19:37

在C#中，多线程访问共享对象时，可能会出现线程安全问题，例如多个线程同时修改同一个对象的状态，导致数据不一致或程序行为异常。为了解决这些问题，C#提供了多种线程同步机制，其中最常用的是锁（Lock）。

多线程访问对象时的锁问题

常见问题：

竞态条件（Race Condition）：
- 多个线程同时访问和修改共享资源，导致结果不可预测。
数据不一致：
- 一个线程修改了数据，而另一个线程读取了未更新的数据。
死锁（Deadlock）：
- 多个线程互相等待对方释放锁，导致程序无法继续执行。

解决方案

C#提供了多种线程同步机制来解决多线程访问对象时的锁问题：

1. `lock` 关键字

lock 是C#中最常用的线程同步机制，它基于Monitor类实现。
使用lock可以确保同一时间只有一个线程访问共享资源。

csharp

private static readonly object _lock = new object();
private static int _counter = 0;

public static void IncrementCounter()
{
    lock (_lock)
    {
        _counter++;
    }
}

2. `Monitor` 类

Monitor 提供了更细粒度的锁控制，可以手动实现Enter和Exit。
lock 关键字是Monitor的语法糖。

csharp

private static readonly object _lock = new object();
private static int _counter = 0;

public static void IncrementCounter()
{
    Monitor.Enter(_lock);
    try
    {
        _counter++;
    }
    finally
    {
        Monitor.Exit(_lock);
    }
}

3. `Mutex` 类

Mutex 是一个跨进程的锁机制，适用于多个进程之间的线程同步。
比lock更重量级，性能较低。

csharp

private static Mutex _mutex = new Mutex();
private static int _counter = 0;

public static void IncrementCounter()
{
    _mutex.WaitOne();
    try
    {
        _counter++;
    }
    finally
    {
        _mutex.ReleaseMutex();
    }
}

4. `Semaphore` 和 `SemaphoreSlim`

Semaphore 用于限制同时访问资源的线程数量。
SemaphoreSlim 是轻量级版本，适用于单进程内的线程同步。

csharp

private static SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
private static int _counter = 0;

public static async Task IncrementCounterAsync()
{
    await _semaphore.WaitAsync();
    try
    {
        _counter++;
    }
    finally
    {
        _semaphore.Release();
    }
}

5. `ReaderWriterLockSlim`

允许多个线程同时读取资源，但只允许一个线程写入资源。
适用于读多写少的场景。

csharp

private static ReaderWriterLockSlim _rwLock = new ReaderWriterLockSlim();
private static int _counter = 0;

public static int ReadCounter()
{
    _rwLock.EnterReadLock();
    try
    {
        return _counter;
    }
    finally
    {
        _rwLock.ExitReadLock();
    }
}

public static void IncrementCounter()
{
    _rwLock.EnterWriteLock();
    try
    {
        _counter++;
    }
    finally
    {
        _rwLock.ExitWriteLock();
    }
}

6. `Interlocked` 类

提供原子操作，适用于简单的数值操作（如递增、递减）。
性能较高，无需显式加锁。

csharp

private static int _counter = 0;

public static void IncrementCounter()
{
    Interlocked.Increment(ref _counter);
}

示例代码：多线程访问共享资源

以下是一个使用lock关键字解决多线程访问共享资源的示例：

csharp

using System;
using System.Threading.Tasks;

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

    static void Main(string[] args)
    {
        Task[] tasks = new Task[10];
        for (int i = 0; i < tasks.Length; i++)
        {
            tasks[i] = Task.Run(IncrementCounter);
        }

        Task.WaitAll(tasks);
        Console.WriteLine($"Final Counter Value: {_counter}"); // 输出: Final Counter Value: 10
    }

    static void IncrementCounter()
    {
        lock (_lock)
        {
            _counter++;
        }
    }
}

死锁问题及避免

死锁示例：

csharp

private static readonly object _lock1 = new object();
private static readonly object _lock2 = new object();

static void Task1()
{
    lock (_lock1)
    {
        Thread.Sleep(100);
        lock (_lock2)
        {
            Console.WriteLine("Task1");
        }
    }
}

static void Task2()
{
    lock (_lock2)
    {
        Thread.Sleep(100);
        lock (_lock1)
        {
            Console.WriteLine("Task2");
        }
    }
}