Is this non-locked TryGetValue() dictionary access thread-safe?

Question

private object lockObj = new object();

private Dictionary<int, string> dict = new Dictionary<int, string>();

public string GetOrAddFromDict(int key)
{
    string value;

    // non-locked access:
    if (dict.TryGetValue(key, out value))
        return value;

    lock (this.lockObj)
    {
        if (dict.TryGetValue(key, out value))
            return value;

        string newValue = "value of " + key; // place long operation here
        dict.Add(key, newValue);

        return newValue;
    }
}

Question a: Is it thread-safe? If yes, why?

Question b: How is this double-TryGetValue() pattern called?

Answer 1

a) This is not thread-safe, as the underlying Dictionary itself is not thread safe. If another thread is calling Add at the same time, undefined behavior can occur.

b) This is effectively an attempt at double-checked locking.

I would recommend using the ConcurrentDictionary class instead, as it's designed for this scenario. Another option would be to use a ReaderWriterLockSlim (or ReaderWriterLock), if you're not targetting .NET 4.0.

Answer 2

Question a: Is it thread-safe? If yes, why?

Not only is it not thread safe; it will also throw with NullReferenceException if accessed while another thread is reorganizing the hash buckets. The lock statement is wicked fast, don't avoid it.

Question b: How is this double-TryGetValue() pattern called?

It's called a 'bug' by most people ;)

Answer 3

Sadly, no.

I carry around a custom HashMap that has this property.

The defect is in the rehash() function.