从Dictionary迁移至ConcurrentDictionary：多线程环境下的注意事项与实现

核心注意事项 #

• ConcurrentDictionary仅保证自身键值对操作的线程安全：它不会自动处理内部List<T>的线程安全问题——多个线程同时读写同一个键对应的List<T>时，依然会出现竞态条件（比如添加元素时的集合修改异常、遍历中途集合变更）。
• 避免拆分操作的原子性：不要单独调用TryGetValue再做修改，因为两次调用之间可能有其他线程修改了目标键值对，必须用ConcurrentDictionary提供的原子方法（GetOrAdd/AddOrUpdate）来封装完整逻辑。
• 性能权衡：ConcurrentDictionary的内部锁粒度比普通Dictionary更细，但依然有额外开销，读多写少场景下优势明显，写极频繁场景需评估是否需要更针对性的优化。

线程安全实现的核心思路 #

要实现完整的线程安全，需要同时处理两层：

1. 键值对层面：依赖ConcurrentDictionary的原子操作方法，避免手动判断键是否存在带来的竞态。
2. 内部集合层面：针对List<T>的线程不安全问题，有两种主流方案：
   • 锁保护List：对每个List<T>实例加锁，确保同一时间只有一个线程修改它。
   • 替换为不可变/线程安全集合：比如用ImmutableList<T>（读多写少场景最优，修改时生成新实例，无锁）或ConcurrentBag<T>（无序场景适用）。

读写增删操作的具体实现 #

1. 读取操作 #

• 仅读取List内容：直接用TryGetValue获取，若只是遍历，建议先复制一份快照（避免遍历中途List被修改抛出异常）：

if (_concurrentDict.TryGetValue(key, out var list))
{
    // 复制快照后遍历，避免原List被修改导致的异常
    var snapshot = list.ToList();
    foreach (var item in snapshot)
    {
        // 处理逻辑
    }
}

• 若使用ImmutableList<T>，可直接遍历，无需复制：

if (_concurrentDict.TryGetValue(key, out var immutableList))
{
    foreach (var item in immutableList)
    {
        // 处理逻辑
    }
}

2. 更新操作（向List添加元素） #

方案1：锁保护List

// 原子获取或创建List，再锁List做修改
var list = _concurrentDict.GetOrAdd(key, k => new List<T>());
lock (list)
{
    list.Add(newItem);
    // 其他修改操作（如Remove、Sort等）也需在锁内执行
}

注意：必须锁list实例本身，不要锁全局对象，避免不必要的阻塞。

方案2：使用ImmutableList（无锁）

// AddOrUpdate原子完成"获取-修改-更新"全流程
_concurrentDict.AddOrUpdate(
    key,
    k => ImmutableList<T>.Empty.Add(newItem), // 键不存在时创建新的ImmutableList
    (k, existingList) => existingList.Add(newItem) // 键存在时生成新实例替换旧值
);

此方案适合读多写少场景，因为每次修改都会生成新集合，写频繁场景会有额外内存开销。

3. 新增键值对 #

直接用GetOrAdd原子完成，避免先判断再添加的竞态：

// 若键不存在则创建空List，存在则返回已有List
var newList = _concurrentDict.GetOrAdd(key, k => new List<T>());

4. 删除操作 #

• 删除键值对：用TryRemove原子删除，若需要处理删除后的List，注意此时其他线程可能已不再访问该List：

if (_concurrentDict.TryRemove(key, out var removedList))
{
    // 处理已删除的List（比如清理资源）
}

• 删除List内的元素：必须在锁内执行（针对锁方案），或生成新的ImmutableList替换（针对无锁方案）：

// 锁方案删除元素
var list = _concurrentDict.GetOrAdd(key, k => new List<T>());
lock (list)
{
    list.Remove(targetItem);
}

// ImmutableList方案删除元素
_concurrentDict.AddOrUpdate(
    key,
    k => ImmutableList<T>.Empty,
    (k, existingList) => existingList.Remove(targetItem)
);

额外优化建议 #

• 若场景允许，优先使用ImmutableList<T>，避免锁带来的线程阻塞。
• 避免在锁内执行IO、复杂计算等耗时操作，减少线程等待时间。
• 遍历整个ConcurrentDictionary时，其枚举器是快照式的，不会抛出集合修改异常，但可能无法反映枚举开始后的最新变更，若需要强一致性遍历，需额外加全局锁（不推荐，会降低性能）。

内容的提问来源于stack exchange，提问作者Pippo