目录
在多线程编程中，线程安全的数据结构是确保数据一致性和避免竞争条件的关键。.NET 提供了多种线程安全的数据结构，适用于不同的场景，本篇将介绍它们的简单使用以及在 .NET Core 和 .NET Framework 中的可用性。
1. ConcurrentQueue
ConcurrentQueue
适用场景
- 生产者-消费者模式：多个生产者线程将数据项添加到队列中，多个消费者线程从队列中取出数据项进行处理
- 任务调度：将任务添加到队列中，由工作线程从队列中取出任务并执行
优点
- 高效的并发操作：支持多个线程同时进行入队和出队操作
- 无锁设计：内部使用无锁算法，避免了锁竞争，提高了性能
- 易于使用：提供简单的 API，如
Enqueue和TryDequeue
可用性
- .NET Framework 4.0 及以上
- .NET Core 1.0 及以上
示例代码
using System.Collections.Concurrent; var queue = new ConcurrentQueue<int>(); var cts = new CancellationTokenSource(); var token = cts.Token; // 生产者任务 var producer = Task.Run(() => { for (int i = 0; i < 10; i++) { queue.Enqueue(i); Console.WriteLine($"Enqueued {i}"); Thread.Sleep(100); // 模拟生产延迟 } }, token); // 消费者任务 var consumer = Task.Run(() => { while (!token.IsCancellationRequested) { if (queue.TryDequeue(out int result)) { Console.WriteLine($"Dequeued {result}"); } Thread.Sleep(50); // 模拟消费延迟 } }, token); await Task.WhenAll(producer); cts.Cancel(); // 停止消费者任务 await consumer; 2. ConcurrentStack
ConcurrentStack
适用场景
- 深度优先搜索算法：在图或树结构中进行深度优先搜索时使用
- 撤销操作：实现撤销功能时，将操作记录入栈，撤销时从栈中弹出操作
优点
- 高效的并发操作：支持多个线程同时进行入栈和出栈操作
- 无锁设计：内部使用无锁算法，避免了锁竞争，提高了性能
- 易于使用：提供简单的 API，如
Push和TryPop
可用性
- .NET Framework 4.0 及以上
- .NET Core 1.0 及以上
示例代码
using System.Collections.Concurrent; var stack = new ConcurrentStack<int>(); var cts = new CancellationTokenSource(); var token = cts.Token; // 生产者任务 var producer = Task.Run(() => { for (int i = 0; i < 10; i++) { stack.Push(i); Console.WriteLine($"Pushed {i}"); Thread.Sleep(100); // 模拟生产延迟 } }, token); // 消费者任务 var consumer = Task.Run(() => { while (!token.IsCancellationRequested) { if (stack.TryPop(out int result)) { Console.WriteLine($"Popped {result}"); } Thread.Sleep(50); // 模拟消费延迟 } }, token); await Task.WhenAll(producer); cts.Cancel(); // 停止消费者任务 await consumer; 3. ConcurrentBag
ConcurrentBag
适用场景
- 任务池：将任务添加到集合中，工作线程从集合中取出任务并执行
- 缓存：将临时数据存储在集合中，多个线程可以并发地添加和删除数据
优点
- 高效的并发操作：支持多个线程同时进行添加和删除操作
- 无锁设计：内部使用无锁算法，避免了锁竞争，提高了性能
- 适用于无序数据：不关心元素顺序的场景非常适用
可用性
- .NET Framework 4.0 及以上
- .NET Core 1.0 及以上
示例代码
using System.Collections.Concurrent; var bag = new ConcurrentBag<int>(); var cts = new CancellationTokenSource(); var token = cts.Token; // 生产者任务 var producer = Task.Run(() => { for (int i = 0; i < 10; i++) { bag.Add(i); Console.WriteLine($"Added {i}"); Thread.Sleep(100); // 模拟生产延迟 } }, token); // 消费者任务 var consumer = Task.Run(() => { while (!token.IsCancellationRequested) { if (bag.TryTake(out int result)) { Console.WriteLine($"Took {result}"); } Thread.Sleep(50); // 模拟消费延迟 } }, token); await Task.WhenAll(producer); cts.Cancel(); // 停止消费者任务 await consumer; 4. ConcurrentDictionary<TKey, TValue>
ConcurrentDictionary<TKey, TValue> 是一个线程安全的键值对集合，类似于 Dictionary<TKey, TValue>。
适用场景
- 缓存：存储键值对数据，多个线程可以并发地读取和写入缓存
- 计数器：存储计数器数据，多个线程可以并发地更新计数器值
优点
- 高效的并发操作：支持多个线程同时进行读取和写入操作
- 原子操作：支持原子操作，如
AddOrUpdate和GetOrAdd，确保数据一致性 - 灵活性：提供丰富的 API，支持多种操作
可用性
- .NET Framework 4.0 及以上
- .NET Core 1.0 及以上
示例代码
using System.Collections.Concurrent; var dictionary = new ConcurrentDictionary<int, string>(); // 添加元素 var addTask = Task.Run(() => { for (int i = 0; i < 10; i++) { dictionary.TryAdd(i, $"value{i}"); Console.WriteLine($"Added key {i} with value value{i}"); } }); // 更新元素 var updateTask = Task.Run(() => { for (int i = 0; i < 10; i++) { var ii = i; dictionary.AddOrUpdate(i, $"new_value{i}", (key, oldValue) => $"new_value{ii}"); Console.WriteLine($"Updated key {i} with value new_value{i}"); } }); // 读取元素 var readTask = Task.Run(() => { foreach (var key in dictionary.Keys) { if (dictionary.TryGetValue(key, out string? value)) { Console.WriteLine($"Key {key} has value {value}"); } } }); await Task.WhenAll(addTask, updateTask, readTask); 5. BlockingCollection
BlockingCollectionConcurrentQueue<T>, ConcurrentStack<T>, ConcurrentBag<T>等一起使用。
适用场景
- 生产者-消费者模式：多个生产者线程将数据项添加到集合中，多个消费者线程从集合中取出数据项进行处理
- 任务调度：将任务添加到集合中，由工作线程从集合中取出任务并执行
优点
- 阻塞操作：支持阻塞添加和移除操作，适用于生产者-消费者模式
- 限界功能：支持设置集合的最大容量，防止过度填充
- 灵活性：可以与多种集合类型一起使用，如
ConcurrentQueue<T>
可用性
- .NET Framework 4.0 及以上
- .NET Core 1.0 及以上
示例代码
using System.Collections.Concurrent; var collection = new BlockingCollection<int>(boundedCapacity: 5); var cts = new CancellationTokenSource(); var token = cts.Token; // 生产者任务 var producer = Task.Run(() => { for (int i = 0; i < 10; i++) { collection.Add(i); Console.WriteLine($"Added {i}"); Thread.Sleep(100); // 模拟生产延迟 } collection.CompleteAdding(); }, token); // 消费者任务 var consumer = Task.Run(() => { foreach (var item in collection.GetConsumingEnumerable(token)) { Console.WriteLine($"Consumed {item}"); Thread.Sleep(50); // 模拟消费延迟 } }, token); await Task.WhenAll(producer, consumer); 6. ImmutableList
ImmutableList
适用场景
- 配置数据：存储配置数据，多个线程可以并发地读取配置数据，而无需担心数据被修改
- 快照：在某个时间点获取数据的快照，多个线程可以并发地读取快照数据
优点
- 天然线程安全：由于集合不可变，多个线程可以安全地并发读取
- 数据一致性：所有修改操作都会返回一个新的集合实例，保证数据一致性
- 易于使用：提供丰富的 API，支持多种操作
可用性
- .NET Framework 4.5 及以上（需要安装
System.Collections.ImmutableNuGet 包） - .NET Core 1.0 及以上（需要安装
System.Collections.ImmutableNuGet 包）
示例代码
var list = ImmutableList.Create(1, 2, 3); var newList = list.Add(4); Console.WriteLine(string.Join(", ", newList)); // 输出 1, 2, 3, 4 7. SynchronizedCollection
SynchronizedCollection
适用场景
- 共享资源管理：管理共享资源的集合，多个线程可以并发地访问和修改集合
- 事件订阅：存储事件订阅者，多个线程可以并发地添加和移除订阅者
优点
- 内置同步机制：自动处理同步，确保线程安全
- 易于使用：提供简单的 API，如
Add和Remove - 灵活性：支持多种集合操作
可用性
- .NET Framework 3.5 及以上
- .NET Core 1.0 及以上
示例代码
var collection = new SynchronizedCollection<int>(); collection.Add(1); collection.Add(2); foreach (var item in collection) { Console.WriteLine(item); // 输出 1 和 2 } 8. SynchronizedReadOnlyCollection
SynchronizedReadOnlyCollection
读集合。
适用场景
- 配置数据：存储只读的配置数据，多个线程可以并发地读取配置数据
- 共享数据：存储共享数据，多个线程可以并发地读取数据，而无需担心数据被修改
优点
- 内置同步机制：自动处理同步，确保线程安全
- 易于使用：提供简单的 API，如
Contains和CopyTo - 数据保护：只读特性确保数据不会被修改
可用性
- .NET Framework 3.0 及以上
- .NET Core 1.0 及以上
示例代码
var list = new List<int> { 1, 2, 3 }; var readOnlyCollection = new SynchronizedReadOnlyCollection<int>(list); foreach (var item in readOnlyCollection) { Console.WriteLine(item); // 输出 1, 2, 3 } 9. SynchronizedKeyedCollection<K, T>
SynchronizedKeyedCollection<K, T> 是一个线程安全的键控集合。
使用场景
- 缓存：存储键控数据，多个线程可以并发地读取和写入缓存
- 资源管理：管理键控资源的集合，多个线程可以并发地访问和修改集合
优点
- 内置同步机制：自动处理同步，确保线程安全
- 键控访问：支持通过键快速访问元素
- 灵活性：支持多种集合操作
可用性
- .NET Framework 3.0 及以上
- .NET Core 1.0 及以上
示例代码
public class MyItem { public int Id { get; set; } public string Name { get; set; } } var collection = new SynchronizedKeyedCollection<int, MyItem>(item => item.Id); collection.Add(new MyItem { Id = 1, Name = "Item1" }); collection.Add(new MyItem { Id = 2, Name = "Item2" }); foreach (var item in collection) { Console.WriteLine(item.Name); // 输出 Item1 和 Item2 } 
