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();}
}
5、总结
- 并发编程
允许同时处理多个任务，通常适用于 CPU 密集型操作。 - 异步编程
允许任务非阻塞地执行，适用于 I/O 密集型任务，如网络请求和文件操作。 - 锁
是并发编程中的关键部分，用于确保线程安全地访问共享资源。
通过合理应用 Task、async/await 以及各种锁机制，可以大幅提升应用程序的性能和响应性，同时避免数据不一致和死锁等并发问题。
