为什么ConcurrentDictionary.GetOrAdd（键，valueFactory）允许valueFactory被调用两次？

问题描述

我使用的是并发的字典作为一个线程安全的静态缓存，发现以下行为：

从的 MSDN文档：

I would like to be able to guarantee that the factory is only called once. Is there any way to do this with the ConcurrentDictionary API without resorting to my own separate synchronization (e. g. locking inside valueFactory)?

My use case is that valueFactory is generating types inside a dynamic module so if two valueFactories for the same key run concurrently I hit:

解决方案

You could use a dictionary that is typed like this: ConcurrentDictionary<TKey, Lazy<TValue>>, and then the your value factory would return a Lazy<TValue> object that has been initialized with LazyThreadSafetyMode.ExecutionAndPublication. By specifying the LazyThreadSafetyMode.ExecutionAndPublication you are telling Lazy only one thread may initialize and set the value of the object.

This results in the ConcurrentDictionary only using one instance of the Lazy<TValue> object, and the Lazy<TValue> object protects more than one thread from initializing its value.

i.e.

var dict = new ConcurrentDictionary<int, Lazy<Foo>>();
dict.GetOrAdd(
    key,  
    (k) => new Lazy<Foo>(
         valueFactory,
         LazyThreadSafetyMode.ExecutionAndPublication
));

The downside then is you'll need to call *.Value every time you are accessing an object in the dictionary. Here are some extensions that'll help with that.

public static class ConcurrentDictionaryExtensions
{
    public static TValue GetOrAdd<TKey, TValue>(
        this ConcurrentDictionary<TKey, Lazy<TValue>> @this,
        TKey key, Func<TKey, TValue> valueFactory
    )
    {
        return @this.GetOrAdd(
            key,
            (k) => new Lazy<TValue>(
                () => valueFactory(k),
                LazyThreadSafetyMode.ExecutionAndPublication
        )).Value;
    }

    public static TValue AddOrUpdate<TKey, TValue>(
        this ConcurrentDictionary<TKey, Lazy<TValue>> @this,
        TKey key, Func<TKey, TValue> addValueFactory,
        Func<TKey, TValue, TValue> updateValueFactory
    )
    {
        return @this.AddOrUpdate(
            key,
            (k) => new Lazy<TValue>(
                () => addValueFactory(k),
                LazyThreadSafetyMode.ExecutionAndPublication
            ),
            (k, currentValue) => new Lazy<TValue>(
                () => updateValueFactory(k, currentValue.Value),
                LazyThreadSafetyMode.ExecutionAndPublication
            )
        ).Value;
    }

    public static bool TryGetValue<TKey, TValue>(
        this ConcurrentDictionary<TKey, Lazy<TValue>> @this,
        TKey key, out TValue value
    )
    {
        value = default(TValue);

        Lazy<TValue> v;
        var result = @this.TryGetValue(key, out v);

        if(result) value = v.Value;

        return result;
   }

   // this overload may not make sense to use when you want to avoid
   //  the construction of the value when it isn't needed
   public static bool TryAdd<TKey, TValue>(
       this ConcurrentDictionary<TKey, Lazy<TValue>> @this,
       TKey key, TValue value
   )
   {
       return @this.TryAdd(key, new Lazy<TValue>(() => value));
   }

   public static bool TryAdd<TKey, TValue>(
    this ConcurrentDictionary<TKey, Lazy<TValue>> @this,
    TKey key, Func<TKey, TValue> valueFactory
   )
   {
       return @this.TryAdd(
           key,
           new Lazy<TValue>(
               () => valueFactory(key),
               LazyThreadSafetyMode.ExecutionAndPublication
           )
       );
   }

   public static bool TryRemove<TKey, TValue>(
       this ConcurrentDictionary<TKey, Lazy<TValue>> @this,
       TKey key, out TValue value
   )
   {
       value = default(TValue);

       Lazy<TValue> v;
       if (@this.TryRemove(key, out v))
       {
           value = v.Value;
           return true;
       }
       return false;
   }

   public static bool TryUpdate<TKey, TValue>(
       this ConcurrentDictionary<TKey, Lazy<TValue>> @this,
       TKey key, Func<TKey, TValue, TValue> updateValueFactory
   )
   {
       Lazy<TValue> existingValue;
       if(!@this.TryGetValue(key, out existingValue))
           return false;

       return @this.TryUpdate(
           key,
           new Lazy<TValue>(
               () => updateValueFactory(key, existingValue.Value),
               LazyThreadSafetyMode.ExecutionAndPublication
           ),
           existingValue
       );
   }
}

这篇关于为什么ConcurrentDictionary.GetOrAdd（键，valueFactory）允许valueFactory被调用两次？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！