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

C# 多线程和异步编程，锁和信号

news 来源：原创 2025/5/12 21:31:39

1. 并发编程与异步编程的区别

1.1 并发编程

并发编程是指同时处理多个任务的能力。多个任务可以是由同一处理器通过任务切换（上下文切换）实现的，也可以通过多核处理器实现多个任务的真正并行处理。并发编程的关键是处理多个任务而不阻塞主任务执行。

1.2 异步编程

异步编程主要用于处理耗时的任务（如 I/O 操作），而不阻塞应用程序的执行。异步编程允许程序继续执行其他任务，而耗时的任务在后台异步执行。

并发编程适用于处理多个并行的工作任务（如 CPU 计算任务）。
异步编程适用于处理非阻塞 I/O 操作（如网络请求、文件读写）。

2. C# 并发编程的关键技术

2.1 Thread 类

C# 提供了 Thread 类来实现并发编程。每个 Thread 对象代表一个独立的线程，线程可以并行执行不同的任务。

示例：启动线程

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        Thread thread = new Thread(new ThreadStart(DoWork));
        thread.Start();
    }

    static void DoWork()
    {
        Console.WriteLine("Work in a separate thread.");
    }
}

注意事项：
使用 Thread 会增加代码的复杂性，因为你需要手动管理线程的生命周期。
线程创建和销毁的开销较大，不适合频繁使用。

2.2 线程池 (ThreadPool)

线程池通过复用现有的线程来减少线程创建和销毁的开销。它自动管理线程的生命周期，适用于轻量、短期任务。

示例：使用 ThreadPool

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        ThreadPool.QueueUserWorkItem(DoWork);
    }

    static void DoWork(object state)
    {
        Console.WriteLine("Work done in thread pool.");
    }
}

优点：
高效地管理并发任务，避免频繁创建和销毁线程。
适用于多个短期并发任务，如处理网络请求、文件读写等。

2.3 任务并行库（Task Parallel Library, TPL）

C# 提供 Task 类，通过 TPL 实现更高级的并发和异步处理方式。相比手动创建线程，Task 更加灵活且容易管理。

示例：创建任务

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Task task = Task.Run(() => DoWork());
        task.Wait();  // 等待任务完成
    }

    static void DoWork()
    {
        Console.WriteLine("Work done using Task.");
    }
}

Task 可以用来启动异步操作并允许更灵活的组合和控制。

2.4 Parallel 类

C# 还提供了 Parallel 类，用于并行执行循环。比如并行处理多个循环迭代、并发执行多个操作。

示例：并行执行 for 循环

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Parallel.For(0, 10, i =>
        {
            Console.WriteLine($"Processing item {i}");
        });
    }
}

Parallel.ForEach 类似于普通 foreach，但会并发执行。

3. C# 异步编程（Async/Await）

3.1 async 和 await

C# 的异步编程模型基于 async 和 await 关键字。async 用于标记方法为异步方法，await 用于等待异步操作完成。

示例：异步方法

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        await PerformWorkAsync();
    }

    static async Task PerformWorkAsync()
    {
        Console.WriteLine("Work started.");
        await Task.Delay(1000);  // 模拟异步操作
        Console.WriteLine("Work completed after 1 second.");
    }
}

async 和 await 的好处：
非阻塞执行：await 表示程序将在任务完成后继续执行，调用线程不会被阻塞。
清晰语法：代码结构类似同步代码，易于编写和维护。

3.2 返回类型

Task：用于没有返回值的异步方法。
Task：用于返回值的异步方法。

示例：异步方法返回值

static async Task<int> GetResultAsync()
{
    await Task.Delay(1000);  // 模拟异步操作
    return 42;
}

3.3 异步流（C# 8.0）

异步流使用 IAsyncEnumerable 和 await foreach 来处理异步数据流。

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        await foreach (var item in GetItemsAsync())
        {
            Console.WriteLine(item);
        }
    }

    static async IAsyncEnumerable<int> GetItemsAsync()
    {
        for (int i = 0; i < 5; i++)
        {
            await Task.Delay(500);  // 模拟异步操作
            yield return i;
        }
    }
}

4. 线程同步与锁定

在并发编程中，当多个线程访问共享资源时，容易引发资源竞争、数据不一致和死锁等问题。C# 提供了多种锁定机制来解决这些问题。

4.1 lock 关键字

lock 是 C# 中最常用的线程同步机制之一，确保同一时刻只有一个线程可以执行 lock 块中的代码。

示例：lock 使用

private static readonly object _lockObject = new object();

void DoWork()
{
    lock (_lockObject)
    {
        // 这段代码在同一时间只能被一个线程执行
        Console.WriteLine("This section is thread-safe.");
    }
}

注意：
使用 lock 会自动阻塞其他试图进入同一代码块的线程，直到当前线程退出 lock 块。
锁对象应尽量小巧且不可变，即通常使用 readonly 修饰符防止锁对象被修改。

4.2 Monitor 类

Monitor 类与 lock 类似，提供更精细的控制，可以手动进入和退出锁定块。

示例：Monitor 使用

private static readonly object _lockObject = new object();

void DoWork()
{
    Monitor.Enter(_lockObject);
    try
    {
        // 执行线程安全的代码
    }
    finally
    {
        Monitor.Exit(_lockObject);
    }
}

Monitor 的使用场景与 lock 类似，但提供了更多方法，例如 Monitor.Wait() 和 Monitor.Pulse()，用于线程间的信号通知。

4.3 Mutex 类

Mutex 是一种系统级的锁，用于跨进程的同步。

示例：使用 Mutex

Mutex mutex = new Mutex();

void DoWork()
{
    mutex.WaitOne();  // 获取互斥锁
    try
    {
        // 执行线程安全代码
    }
    finally
    {
        mutex.ReleaseMutex();  // 释放互斥锁
    }
}

4.4 Semaphore 和 SemaphoreSlim

Semaphore 允许多个线程同时访问一个资源，并控制并发访问的数量。SemaphoreSlim 是轻量版本，主要用于单进程内。

示例：SemaphoreSlim

SemaphoreSlim semaphore = new SemaphoreSlim(3);  // 最多允许3个线程并发访问

async Task DoWorkAsync()
{
    await semaphore.WaitAsync();
    try
    {
        // 访问共享资源
    }
    finally
    {
        semaphore.Release();  // 释放信号量
    }
}

4.5 ReaderWriterLockSlim

ReaderWriterLockSlim 允许多个读线程并发执行，但写线程需要独占访问。

示例：ReaderWriterLockSlim

ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();

void Read()
{
    rwLock.EnterReadLock();
    try
    {
        // 读取共享数据
    }
    finally
    {
        rwLock.ExitReadLock();
    }
}

void Write()
{
    rwLock.EnterWriteLock();
    try
    {
        // 写入共享数据
    }
    finally
    {
        rwLock.ExitWriteLock();
    }
}