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

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 (!@this.TryGetValue(key, out Lazy<TValue> existingValue))           return false;       return @this.TryUpdate(key,           new Lazy<TValue>(               () => updateValueFactory(key, existingValue.Value)           ),           existingValue       );   }}

This is not uncommon with Non-Blocking Algorithms. They essentially test for a condition confirming there is no contention using Interlock.CompareExchange. They loop around though until the CAS succeeds. Have a look at ConcurrentQueue page (4) as a good intro to Non-Blocking Algorithms

Short answer is no, it's the nature of the beast that it will require multiple attempts to add to the collection under contention.Other than using the other overload of passing a value, you'd need to protect against multiple calls inside your value factory, perhaps using a double lock / memory barrier.