社区首页 >专栏 >NET中的线程锁

NET中的线程锁

郑子铭

发布于 2025-03-24 07:05:02

12600

代码可运行

文章被收录于专栏：DotNet NB && CloudNativeDotNet NB && CloudNative

运行总次数：0

代码可运行

在.NET中，线程锁（Thread Locking）是一种重要的同步机制，用于确保多个线程在访问共享资源时不会发生冲突，保证线程安全。线程锁的核心目标是避免数据竞争和不一致的状态，确保在同一时刻只有一个线程能够访问特定的资源或代码块。本文将详细讲解.NET中的线程锁，帮助你理解其工作原理、常见实现方式及注意事项。

常见的线程锁有：

• 自旋锁：当线程尝试获取锁时，它会重复执行一些简单的指令，直到锁可用
• 互斥锁: Mutex，可以跨进程使用。Mutex 类定义了一个互斥体对象，可以使用 WaitOne() 方法等待对象上的锁
• 混合锁：Monitor，可以通过 lock 关键字来使用
• 读写锁：允许多个线程同时读取共享资源，但只允许单个线程写入共享资源
• 信号量：Semaphore，它允许多个线程同时访问同一个资源来源：Z7TS

1. 为什么需要线程锁？

在多线程编程中，多个线程可能同时访问共享资源（如变量、文件、数据库等）。如果多个线程在没有同步机制的情况下同时访问同一资源，可能会导致以下问题：

• 数据竞争：不同线程同时修改相同数据，导致数据不一致。
• 竞态条件：由于线程的执行顺序不可预测，可能会出现不正确的结果。

为了避免这些问题，我们需要使用线程锁来控制对共享资源的访问，确保每次只有一个线程能访问临界区（Critical Section）。

2. .NET 中线程锁的实现方式

在.NET中，线程锁的实现方式主要有以下几种：

(1) `lock` 关键字

lock 是.NET中最常用的线程锁机制。它是 Monitor.Enter 和 Monitor.Exit 的简化封装。通过使用 lock，你可以锁定一个对象，确保同一时刻只有一个线程能够进入被锁定的代码块。

使用方法：

class Program
{
    privatestaticreadonlyobject lockObject = newobject();

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

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

    static void Method()
    {
        // 使用 lock 锁定临界区
        lock (lockObject)
        {
            Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId} 正在执行");
            Thread.Sleep(1000);  // 模拟耗时操作
        }
    }
}

在此例中，lock 关键字会锁定 lockObject 对象，使得 Method 方法内的代码在任意时刻只能被一个线程执行。

(2) `Monitor` 类

Monitor 类是 .NET 提供的低级别同步工具，lock 背后就是基于 Monitor 的实现。Monitor 提供了更精细的控制，可以手动获取和释放锁。

使用方法：

class Program
{
    privatestaticreadonlyobject lockObject = newobject();

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

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

    static void Method()
    {
        Monitor.Enter(lockObject);  // 显式获取锁

        try
        {
            Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId} 正在执行");
            Thread.Sleep(1000);  // 模拟耗时操作
        }
        finally
        {
            Monitor.Exit(lockObject);  // 确保释放锁
        }
    }
}

在这个例子中，Monitor.Enter 手动获取锁，Monitor.Exit 释放锁。使用 try-finally 确保即使发生异常，也能释放锁。

(3) `Mutex` 类

Mutex 是一种更为强大的锁机制，通常用于不同进程之间的同步。它不仅支持跨线程同步，还支持跨进程同步。与 lock 或 Monitor 只限于线程级别的同步不同，Mutex 主要用于操作系统级别的锁。

使用方法：

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

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

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

    static void Method()
    {
        mutex.WaitOne();  // 获取 Mutex 锁

        try
        {
            Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId} 正在执行");
            Thread.Sleep(1000);  // 模拟耗时操作
        }
        finally
        {
            mutex.ReleaseMutex();  // 释放 Mutex 锁
        }
    }
}

Mutex 的 WaitOne() 方法获取锁，ReleaseMutex() 方法释放锁。Mutex 的主要优势在于它可以用于跨进程同步，但性能上比 lock 和 Monitor 更重。

(4) `Semaphore` 和 `SemaphoreSlim`

Semaphore 是一种允许多个线程同时访问某个资源的同步机制。它通过设置一个计数器来控制最多多少个线程可以同时访问一个特定资源。当计数器为零时，新的线程必须等待其他线程释放资源。

SemaphoreSlim 是 Semaphore 的轻量级版本，适用于线程同步。

使用方法（SemaphoreSlim）：

class Program
{
    privatestatic SemaphoreSlim semaphore = new SemaphoreSlim(2);  // 最大同时允许2个线程访问

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

        t1.Start();
        t2.Start();
        t3.Start();
    }

    static void Method()
    {
        semaphore.Wait();  // 获取信号量

        try
        {
            Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId} 正在执行");
            Thread.Sleep(1000);  // 模拟耗时操作
        }
        finally
        {
            semaphore.Release();  // 释放信号量
        }
    }
}

这个例子中，最多允许 2 个线程同时执行 Method 方法。

3. 线程锁的注意事项

1. 死锁（Deadlock）：死锁是指两个或多个线程互相等待对方释放锁，从而导致程序无法继续执行。避免死锁的策略包括：
- • 按固定顺序获取锁。
- • 使用 Monitor.TryEnter 来尝试获取锁，而不是无限期等待。
2. 性能问题：虽然线程锁能够确保线程安全，但不当使用可能会导致性能瓶颈，尤其是当锁的粒度较大时。尽量缩小锁的范围，并避免长时间持有锁。
3. 可重入性：lock 和 Monitor 都是可重入的，即同一个线程可以多次进入同一个锁定区域，而不会发生死锁。
4. 选择合适的锁类型：选择合适的锁类型非常重要。如果只是保护一个线程内部的资源，lock 是最简便的选择。如果涉及到多个进程之间的同步，Mutex 是更好的选择。