ConcurrentDictionary.GetOrAdd 真的是线程安全的吗？

我有这段代码，如果该任务是为相同的输入创建的，我想等待正在进行的任务。这是我正在做的事情的最小再现。

private static ConcurrentDictionary<int, Task<int>> _tasks = new ConcurrentDictionary<int, Task<int>>();

private readonly ExternalService _service;


public async Task SampleTask(){
  var result = await _service.DoSomething();
  await Task.Delay(1000) //this task takes some time do finish
  return result;
}

public async Task<int> DoTask(int key) {
   var task = _tasks.GetOrAdd(key, _ => SampleTask());
   var taskResult = await task;
   _tasks.TryRemove(key, out task);
   return taskResult;
}

我正在编写一个测试，以确保当多个请求想要（大致）同时执行任务时等待相同的任务。我通过嘲笑来做到这一点_service并数数有多少次_service.DoSomething()正在被呼叫。如果调用的话，应该只有一次DoTask(int key)大约是在同一时间制作的。

然而，结果表明，如果我打电话DoTask(int key)多次调用之间的延迟小于 1~2ms，两个任务都将创建并执行其实例SampleTask()用第二个替换字典中的第一个。

考虑到这一点，我们可以说这个方法是真正的线程安全的吗？或者我的问题本身不是线程安全的情况吗？

去引用文档 https://learn.microsoft.com/en-us/dotnet/api/system.collections.concurrent.concurrentdictionary-2.getoradd?view=netframework-4.7.2#System_Collections_Concurrent_ConcurrentDictionary_2_GetOrAdd__0_System_Func__0__1__（强调我的）：

对于字典的修改和写入操作，ConcurrentDictionary<TKey,TValue> https://learn.microsoft.com/en-us/dotnet/api/system.collections.concurrent.concurrentdictionary-2?view=netframework-4.7.2使用细粒度锁定来保证线程安全。 （对字典的读取操作是以无锁方式执行的。）但是，valueFactorydelegate 在锁之外调用，以避免在锁下执行未知代码时可能出现的问题。所以，GetOrAdd https://learn.microsoft.com/en-us/dotnet/api/system.collections.concurrent.concurrentdictionary-2.getoradd?view=netframework-4.7.2对于所有其他操作来说不是原子的ConcurrentDictionary<TKey,TValue> class.

由于键/值可以由另一个线程插入valueFactory正在产生价值，你不能仅仅因为它就相信它valueFactory执行后，其产生的值将被插入到字典中并返回。如果你打电话GetOrAdd同时在不同线程上，valueFactory可能会被调用多次，但只会将一个键/值对添加到字典中。

因此，虽然字典是正确的线程安全的，但调用valueFactory, or _ => SampleTask()就您而言，不能保证是唯一的。所以你的工厂函数应该能够接受这个事实。

您可以确认这一点从源头 https://referencesource.microsoft.com/#mscorlib/system/Collections/Concurrent/ConcurrentDictionary.cs,1059:

public TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory)
{
    if (key == null) throw new ArgumentNullException("key");
    if (valueFactory == null) throw new ArgumentNullException("valueFactory");

    TValue resultingValue;
    if (TryGetValue(key, out resultingValue))
    {
        return resultingValue;
    }
    TryAddInternal(key, valueFactory(key), false, true, out resultingValue);
    return resultingValue;
}

如你看到的，valueFactory正在被外部调用TryAddInternal它负责正确锁定字典。

然而，自从valueFactory是一个 lambda 函数，它在您的情况下返回一个任务（_ => SampleTask()），并且字典不会等待该任务本身，该函数将完成quickly并返回不完整的Task遇到第一个之后await（当异步状态机设置时）。因此，除非调用非常快地接二连三，否则任务应该很快添加到字典中，并且后续调用将重用相同的任务。

如果您要求这种情况只发生一次all在这种情况下，您应该考虑自己锁定任务创建。由于它会很快完成（无论您的任务实际需要多长时间才能解决），锁定不会造成太大影响。