C# 多线程编程：线程锁与无锁并发

原创

已于 2024-03-28 19:54:08 修改 · 4k 阅读

标签

#c#

于 2024-03-28 19:23:42 首次发布

文章目录

前言
一、锁的基本概念
二、线程锁的类型
三、锁的实现方式
四、无锁并发编程
五、并发集合类
六、经典并发同步问题
总结

前言

多线程编程在现代软件开发中至关重要。本文将讨论 C# 中的多线程技术，重点介绍锁的概念，线程锁与无锁并发。通过学习本篇博文，我们将学会如何正确处理并发问题，提高程序的性能和稳定性。

一、锁的基本概念

在多线程编程中，掌握锁的概念至关重要。本节将介绍什么是锁，为什么我们需要锁以及锁的作用原理。

1.1 什么是锁？

锁是一种同步机制，用于控制多个线程对共享资源的访问。当一个线程获得了锁时，其他线程将被阻塞，直到该线程释放了锁。

1.2 为什么需要锁？

在并发编程中，多个线程同时访问共享资源可能导致数据竞争和不确定的行为。锁可以确保在任意时刻只有一个线程可以访问共享资源，从而避免竞态条件和数据不一致性问题。

1.3 锁的作用原理

锁的作用原理通常涉及到内部的互斥机制。当一个线程获得锁时，它会将锁标记为已被占用，其他线程尝试获取该锁时会被阻塞，直到持有锁的线程释放锁。这种互斥机制可以通过不同的算法和数据结构来实现，如互斥量、自旋锁等。

理解锁的概念是进行多线程编程的基础，它为我们提供了一种可靠的方式来保护共享资源，确保线程安全和程序的正确性。在接下来的章节中，我们将深入探讨不同类型的锁以及它们在 C# 多线程编程中的应用。

二、线程锁的类型

在多线程编程中，锁的实现通常基于互斥机制，确保在任意时刻只有一个线程可以访问共享资源。本节将介绍几种常见的锁类型，包括自旋锁、互斥锁、混合锁和读写锁。

2.1 自旋锁（Spin Lock）

自旋锁是一种基于忙等待的锁，当线程尝试获取锁时，如果发现锁已被其他线程占用，它会循环（自旋）等待，不断地检查锁是否被释放。

自旋锁适用于锁的占用时间短、线程并发度高的情况，因为它避免了线程在等待锁时进入内核态造成的性能损失。

但自旋锁可能会导致线程空转消耗 CPU 资源，因此不适合在锁被占用时间较长或竞争激烈的情况下使用。

2.2 互斥锁（Mutex）

互斥锁是一种阻塞式锁，它通过操作系统提供的原语实现，当线程尝试获取锁时，如果发现锁已被其他线程占用，它会被阻塞，直到锁被释放。

互斥锁适用于锁的占用时间长、线程竞争激烈的情况，因为它可以将等待锁的线程置于休眠状态，避免空转浪费 CPU 资源。

但互斥锁由于涉及系统调用，因此会产生较大的开销，尤其在高并发情况下可能成为性能瓶颈。

2.3 混合锁（Hybrid Lock）

混合锁是结合了自旋锁和互斥锁的优点，根据锁的占用情况动态选择使用自旋等待还是阻塞等待。

在锁的竞争不激烈时，混合锁会采用自旋等待的方式，避免线程进入内核态；而在锁的竞争激烈时，会转为阻塞等待，以减少空转和CPU资源的浪费。

混合锁的实现较为复杂，需要根据具体的场景进行调优，以达到最佳的性能和资源利用率。

2.4 读写锁（Read-Write Lock）

读写锁允许多个线程同时对共享资源进行读取操作，但在进行写入操作时需要互斥。

读写锁适用于读操作远远多于写操作的场景，可以提高程序的并发性能。

读写锁通常包含一个写锁和多个读锁，当写锁被占用时，所有的读锁和写锁都会被阻塞；而当读锁被占用时，其他的读锁仍然可以被获取，但写锁会被阻塞。

三、锁的实现方式

下面是几种常见的锁类型：

3.1 Monitor（互斥体）

Monitor 是 C# 中最基本的锁机制之一，它使用 lock 关键字来实现。lock 关键字在进入代码块时获取锁，在退出代码块时释放锁。这确保了在同一时刻只有一个线程可以执行 lock 块中的代码。

using System;
using System.Threading;

class Program
{
   
   
    private static object _lock = new object();

    static void Main(string[] args)
    {
   
   
        // 启动两个线程访问临界区
        Thread thread1 = new Thread(EnterCriticalSection);
        Thread thread2 = new Thread(EnterCriticalSection);

        thread1.Start();
        thread2.Start();
    }

    static void EnterCriticalSection()
    {
   
   
        // 进入临界区
        Monitor.Enter(_lock);
        try
        {
   
   
            // 在临界区内操作共享资源
            Console.WriteLine($"Thread {
     
     Thread.CurrentThread.ManagedThreadId} entered critical section.");
            Thread.Sleep(2000);
        }
        finally
        {
   
   
            // 退出临界区
            Monitor.Exit(_lock);
            Console.WriteLine($"Thread {
     
     Thread.CurrentThread.ManagedThreadId} exited critical section.");
        }
    }
}

另一种写法：

object lockObj = new object();
lock (lockObj)
{
   
   
    // 执行需要同步的代码
}

3.2 Mutex（互斥体）

Mutex 是一种操作系统级别的同步原语，与 Monitor 不同，Mutex 可以在进程间共享。Mutex 是一个系统对象，它可以在全局范围内唯一标识一个锁。使用 Mutex 需要在代码中声明一个 Mutex 对象，然后通过 WaitOne 和 ReleaseMutex 方法来获取和释放锁。

using System;
using System.Threading;

class Program
{
   
   
    private static Mutex _mutex = new Mutex();

    static void Main(string[] args)
    {
   
   
        // 启动两个线程访问临界区
        Thread thread1 = new Thread(EnterCriticalSection);
        Thread thread2 = new Thread(EnterCriticalSection);

        thread1.Start();
        thread2.Start();
    }

    static void EnterCriticalSection()
    {
   
   
        // 等待获取 Mutex
        _mutex.WaitOne();
        try
        {
   
   
            // 在临界区内操作共享资源
            Console.WriteLine($"Thread {
     
     Thread.CurrentThread.ManagedThreadId} entered critical section.");
            Thread.Sleep(2000);
        }
        finally
        {
   
   
            // 释放 Mutex
            _mutex.ReleaseMutex();
            Console.WriteLine($"Thread {
     
     Thread.CurrentThread.ManagedThreadId} exited critical section.");
        }
    }
}

3.3 Semaphore（信号量）

Semaphore 是一种允许多个线程同时访问共享资源的同步原语。它通过一个计数器来控制同时访问资源的线程数量。Semaphore 构造函数需要指定初始的计数器值和最大的计数器值。通过 WaitOne 和 Release 方法来获取和释放信号量。

using System;
using System.Threading;

class Program
{
   
   
    private static Semaphore _semaphore = new Semaphore(2, 2); // 允许最多两个线程同时访问

    static void Main(string[] args)
    {
   
   
        // 启动五个线程访问临界区
        for (int i = 0; i < 5; i++)
        {
   
   
            Thread thread = new Thread(EnterCriticalSection);
            thread.Start(i);
        }
    }

    static void EnterCriticalSection(object threadId)
    {
   
   
        // 等待获取 Semaphore
        _semaphore.WaitOne();
        try
        {
   
   
            // 在临界区内操作共享资源
            Console.WriteLine($"Thread {
     
     threadId} entered critical section.");
            Thread.Sleep(2000);
        }
        finally
        {
   
   
            // 释放 Semaphore
            _semaphore.Release();
            Console.WriteLine($"Thread {
     
     threadId} exited critical section.");
        }
    }
}

3.4 ReaderWriterLock（读写锁）

ReaderWriterLock 是一种特殊的锁机制，它允许多个线程同时读取共享资源，但在写入资源时需要互斥。这种锁适用于读操作远远多于写操作的场景，可以提高性能。

using System;
using System.Threading;

class Program
{
   
   
    private static ReaderWriterLockSlim _rwLock = new ReaderWriterLockSlim();

    static void Main(string[] args)
    {
   
   
        // 启动五个读线程和一个写线程访问共享资源
        for (int i = 0; i < 5; i++)
        {
   
   
            Thread readerThread = new Thread(ReadSharedResource);
            readerThread.Start(i);
        }

        Thread writerThread = new Thread(WriteSharedResource);
        writerThread.Start();
    }

    static void ReadSharedResource(object threadId)
    {
   
   
        _rwLock.EnterReadLock();
        try
        {
   
   
            // 读取共享资源
            Console.WriteLine($"Reader {
     
     threadId} read shared resource.");
            Thread.Sleep(2000);
        }
        finally
        {
   
   
            _rwLock.ExitReadLock();
        }
    }

    static void WriteSharedResource()
    {
   
   
        _rwLock.EnterWriteLock();
        try
        {
   
   
            // 写入共享资源
            Console.WriteLine("Writer wrote shared resource.");
            Thread.Sleep(1000);
        }
        finally
        {
   
   
            _rwLock.ExitWriteLock();
        }
    }
}

四、无锁并发编程

在多线程编程中，除了使用锁机制来保护共享资源外，还可以通过无锁并发编程来实现并发控制。本章将介绍无锁并发编程的概念、优势以及常见的无锁算法。

4.1 无锁并发编程的概念

无锁并发编程是一种基于原子操作的并发控制方式，它不需要使用传统的锁机制来保护共享资源，而是通过原子性操作来确保线程安全。无锁并发编程通常比锁机制具有更低的开销和更高的性能。

4.2 无锁算法

4.2.1 CAS（Compare And Swap）

CAS 是一种原子操作，通常由处理器提供支持。它涉及三个操作数：内存位置（通常是一个地址）、旧的预期值和新的值。如果内存位置的值与预期值相等，则将新值写入该位置；否则，操作失败。

using System;
using System.Threading;

class Program
{
   
   
    static int sharedValue = 0;

    static void Main(string[] args)
    {
   
   
        // 使用 CAS 算法更新共享变量
        int expectedValue = 0;
        int newValue = 1;
        if (Interlocked.CompareExchange(ref sharedValue, newValue, expectedValue) == expectedValue)
        {
   
   
            Console.WriteLine("Value updated successfully."

最低0.47元/天解锁文章