c# ConcurrentDictionary的GetOrAdd和AddOrUpdate是原子操作吗

在C#的System.Collections.Concurrent命名空间中，ConcurrentDictionary是为多线程场景设计的线程安全字典，其中的GetOrAdd和AddOrUpdate是高频使用的方法，很多开发者会默认这两个方法是原子操作，但实际需要结合具体场景判断。

方法基本功能说明

GetOrAdd方法的作用是获取指定键对应的值，如果键不存在就添加对应的键值对并返回值。AddOrUpdate方法的作用是更新指定键对应的值，如果键不存在就添加对应的键值对，返回更新后或添加的值。

两个方法的常用重载形式如下：

// GetOrAdd 重载示例
public TValue GetOrAdd(TKey key, TValue value);
public TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory);

// AddOrUpdate 重载示例
public TValue AddOrUpdate(TKey key, TValue addValue, Func<TKey, TValue, TValue> updateValueFactory);
public TValue AddOrUpdate(TKey key, Func<TKey, TValue> addValueFactory, Func<TKey, TValue, TValue> updateValueFactory);

原子性的实际分析

GetOrAdd的原子性情况

GetOrAdd方法的核心操作是线程安全的，但是当使用Func<TKey, TValue>委托作为值工厂的重载时，值工厂的执行不是原子操作的一部分。

ConcurrentDictionary内部会保证键的查找和添加操作是原子的，但是值工厂的委托调用是在锁外部执行的，也就是说多个线程同时调用GetOrAdd时，可能会同时触发值工厂的执行，导致值工厂被多次调用，但是最终只会有一个线程添加的结果被保留到字典中。

我们可以通过下面的示例验证这个现象：

using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        ConcurrentDictionary<int, int> dict = new ConcurrentDictionary<int, int>();
        int callCount = 0;
        
        // 多个线程同时调用GetOrAdd，使用值工厂
        Parallel.For(0, 10, i =>
        {
            dict.GetOrAdd(1, k =>
            {
                // 值工厂被调用时计数
                System.Threading.Interlocked.Increment(ref callCount);
                System.Threading.Thread.Sleep(100); // 模拟耗时操作
                return 100;
            });
        });
        
        Console.WriteLine($"值工厂被调用次数：{callCount}");
        Console.WriteLine($"字典中键1的值：{dict[1]}");
    }
}

运行上述代码会发现，值工厂的调用次数可能大于1，但是字典中键1的值始终是100，这说明值工厂的执行不是原子的，只是最终的添加操作是线程安全的。

AddOrUpdate的原子性情况

AddOrUpdate方法的更新逻辑是原子的，但是值工厂的执行同样不在原子操作范围内。当使用委托作为添加或更新的值工厂时，多个线程同时调用AddOrUpdate，可能会导致添加或更新的委托被多次执行，但是最终的键值对更新是符合线程安全要求的。

下面的示例可以说明这个问题：

using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        ConcurrentDictionary<int, int> dict = new ConcurrentDictionary<int, int>();
        int addCallCount = 0;
        int updateCallCount = 0;
        
        // 多个线程同时调用AddOrUpdate
        Parallel.For(0, 10, i =>
        {
            dict.AddOrUpdate(1, 
                k => 
                {
                    System.Threading.Interlocked.Increment(ref addCallCount);
                    return 0;
                }, 
                (k, oldValue) =>
                {
                    System.Threading.Interlocked.Increment(ref updateCallCount);
                    return oldValue + 1;
                });
        });
        
        Console.WriteLine($"添加委托调用次数：{addCallCount}");
        Console.WriteLine($"更新委托调用次数：{updateCallCount}");
        Console.WriteLine($"字典中键1的最终值：{dict[1]}");
    }
}

运行后会发现添加委托和更新委托都可能被多次调用，但是最终字典中的值是线程安全更新后的结果，不会出现数据损坏的情况。

实际使用注意事项

• 如果值工厂的执行有副作用，比如操作数据库、写入文件等，不要直接使用GetOrAdd或AddOrUpdate的委托重载，避免副作用被多次执行。
• 如果只是需要简单的键值对添加或更新，优先使用传入具体值的重载，而不是委托重载，减少不必要的委托执行开销。
• 如果需要保证值工厂只执行一次，可以在外部先计算结果，再传入GetOrAdd或AddOrUpdate，或者使用额外的锁机制控制值工厂的执行。

总结

ConcurrentDictionary的GetOrAdd和AddOrUpdate方法本身的键值对操作是原子的，但是当使用委托作为值工厂时，委托的执行不属于原子操作的一部分，可能会出现多次执行的情况。开发者在使用这两个方法时，需要根据值工厂是否有副作用来判断是否符合自己的需求，避免出现非预期的逻辑问题。

ConcurrentDictionaryGetOrAddAddOrUpdate原子操作修改时间：2026-06-15 07:54:29