Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Why does ConcurrentDictionary.GetOrAdd(key, valueFactory) allow the valueFactory to be invoked twice?

I am using a concurrent dictionary as a thread-safe static cache and noticed the following behavior:

From the MSDN docs on GetOrAdd:

If you call GetOrAdd simultaneously on different threads, addValueFactory may be called multiple times, but its key/value pair might not be added to the dictionary for every call.

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:

System.ArgumentException: Duplicate type name within an assembly.

like image 394
ChaseMedallion Avatar asked Sep 26 '12 22:09

ChaseMedallion


People also ask

Is GetOrAdd thread-safe?

The GetOrAdd functionThe vast majority of methods it exposes are thread safe, with the notable exception of one of the GetOrAdd overloads: TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory); This overload takes a key value, and checks whether the key already exists in the database.

Is ConcurrentDictionary thread-safe?

Concurrent. ConcurrentDictionary<TKey,TValue>. This collection class is a thread-safe implementation. We recommend that you use it whenever multiple threads might be attempting to access the elements concurrently.

What is the purpose of the ConcurrentDictionary?

ConcurrentDictionary is thread-safe collection class to store key/value pairs. It internally uses locking to provide you a thread-safe class. It provides different methods as compared to Dictionary class. We can use TryAdd, TryUpdate, TryRemove, and TryGetValue to do CRUD operations on ConcurrentDictionary.

What is the purpose of the ConcurrentDictionary TKey TValue class in C#?

ConcurrentDictionary<TKey, TValue> Class Represents a thread-safe collection of key-value pairs that can be accessed by multiple threads concurrently.


1 Answers

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, which is the default option used by Lazy<TValue> if you don't specify it. 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) ); 

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))         ).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)),             (k, currentValue) => new Lazy<TValue>(                 () => updateValueFactory(k, currentValue.Value)             )         ).Value;     }      public static bool TryGetValue<TKey, TValue>(         this ConcurrentDictionary<TKey, Lazy<TValue>> @this,         TKey key, out TValue value     )     {         value = default(TValue);          var result = @this.TryGetValue(key, out Lazy<TValue> 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))        );    }     public static bool TryRemove<TKey, TValue>(        this ConcurrentDictionary<TKey, Lazy<TValue>> @this,        TKey key, out TValue value    )    {        value = default(TValue);         if (@this.TryRemove(key, out Lazy<TValue> 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    )    {        if ([email protected](key, out Lazy<TValue> existingValue))            return false;         return @this.TryUpdate(key,            new Lazy<TValue>(                () => updateValueFactory(key, existingValue.Value)            ),            existingValue        );    } } 
like image 103
JG in SD Avatar answered Oct 17 '22 11:10

JG in SD