修改并发容器中存储的元素时是否需要同步对象？

嘿，这个问题踩过坑的人都懂——ConcurrentDictionary只保证它自身的键值对操作（比如添加、删除、查找整个对象）是线程安全的，完全管不了你存进去的TaskResult对象内部的属性修改！所以结论是：必须加额外的同步/线程安全机制！

为什么需要同步？ #

ConcurrentDictionary的线程安全只覆盖到“键值对级别”：比如你用_results.TryGetValue()拿到一个TaskResult实例，这个动作是原子的，但拿到实例之后，多个线程同时修改它的CompletedSoFar或Done属性时，就会出现竞态条件——比如两个线程同时读取CompletedSoFar = 0，各自加1后写入，最终结果可能还是1而不是2，这就是典型的线程不安全问题。

举个反例，这段代码是有风险的：

// 多个线程同时执行这段代码的话，CompletedSoFar的修改会出问题
var result = _results[taskGuid];
result.CompletedSoFar++;

几种可行的解决方案 #

根据你的场景，推荐以下几种处理方式：

1. 在TaskResult内部加锁，保证属性修改的原子性

给TaskResult加一个私有锁对象，所有对内部字段的读写都通过锁保护：

public class TaskResult {
    private readonly object _lockObj = new object();
    private int _completedSoFar;
    private bool _done;

    public TaskResult() {
        _completedSoFar = 0;
        _done = false;
    }

    [DataMember(Order = 0)]
    public int CompletedSoFar {
        get { lock (_lockObj) return _completedSoFar; }
        set { lock (_lockObj) _completedSoFar = value; }
    }

    [DataMember(Order = 1)]
    public bool Done {
        get { lock (_lockObj) return _done; }
        set { lock (_lockObj) _done = value; }
    }

    // 可以封装常用操作，比如原子递增，避免外部直接操作字段
    public void IncrementCompleted() {
        lock (_lockObj) _completedSoFar++;
    }
}

这种方式简单直观，适合大多数场景，只要确保所有修改TaskResult属性的地方都通过它的方法或加锁的属性来操作就行。

2. 使用线程安全的字段类型（轻量级方案）

对于简单的数值或布尔类型，可以用Interlocked类或者volatile关键字来实现无锁的线程安全：

public class TaskResult {
    private int _completedSoFar;
    private volatile bool _done;

    public TaskResult() {
        _completedSoFar = 0;
        _done = false;
    }

    [DataMember(Order = 0)]
    public int CompletedSoFar {
        get => Interlocked.CompareExchange(ref _completedSoFar, 0, 0); // 原子读取
        set => Interlocked.Exchange(ref _completedSoFar, value); // 原子写入
    }

    [DataMember(Order = 1)]
    public bool Done {
        get => _done;
        set => _done = value; // volatile保证读写的可见性
    }

    // 原子递增的高效实现
    public void IncrementCompleted() {
        Interlocked.Increment(ref _completedSoFar);
    }
}

这种方式比锁更轻量，适合频繁修改简单字段的场景，缺点是只对单一字段的操作有效，如果需要同时修改多个字段（比如同时更新CompletedSoFar和Done），还是得用锁。

3. 把TaskResult改成不可变类型（无锁方案）

让TaskResult的属性只读，每次修改都创建一个新的实例，然后用ConcurrentDictionary的原子替换方法更新整个对象：

public class TaskResult {
    // 属性只读，构造时初始化
    public int CompletedSoFar { get; }
    public bool Done { get; }

    public TaskResult(int completedSoFar, bool done) {
        CompletedSoFar = completedSoFar;
        Done = done;
    }

    // 提供修改方法，返回新实例而不是修改当前实例
    public TaskResult WithIncrementedCompleted() {
        return new TaskResult(CompletedSoFar + 1, Done);
    }

    public TaskResult WithDone(bool done) {
        return new TaskResult(CompletedSoFar, done);
    }
}

然后修改的时候用ConcurrentDictionary的AddOrUpdate方法：

// 原子替换现有对象为新实例
_results.AddOrUpdate(taskGuid,
    key => new TaskResult(1, false), // 如果键不存在则创建新对象
    (key, existing) => existing.WithIncrementedCompleted()); // 如果存在则替换为修改后的新实例

这种方式完全不需要锁，因为对象不可变，线程之间不会互相干扰，但频繁创建对象可能有轻微的性能开销，适合修改不那么频繁的场景。

总结 #

ConcurrentDictionary的线程安全范围是它自己的键值对集合操作，和你存进去的对象内部状态无关。要保证TaskResult属性修改的线程安全，必须自己在对象内部或者修改逻辑里加保护机制，具体选哪种方案取决于你的性能要求和代码复杂度。

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