使用 foo[bar] = baz 添加到 ConcurrentDictionary 是否线程安全？

Question

I'm not a fan of the methods attached to the ConcurrentDictionary . AddOrUpdate requires a func and GetOrAdd adds when you are just looking for the key to get the value. So I want to use it like a normal dictionary (I'm using ContainsKey to be safe)

The docs say "To store a key/value pair in the dictionary unconditionally, and overwrite the value of a key that already exists", use The indexer's setter: dictionary[key] = newValue .

But is this operation still threadsafe? The comments at the bottom say "All public and protected members of ConcurrentDictionary are thread-safe and may be used concurrently from multiple threads." But I'm not 100% sure that they consider the above setter to be included here.

Answer 1

You can check the indexer implementation of ConcurrentDictionary at reference source -- https://referencesource.microsoft.com/#mscorlib/system/Collections/Concurrent/ConcurrentDictionary.cs

    public TValue this[TKey key]
    {
        get
        {
            TValue value;
            if (!TryGetValue(key, out value))
            {
                throw new KeyNotFoundException();
            }
            return value;
        }
        set
        {
            if (key == null) throw new ArgumentNullException("key");
            TValue dummy;
            TryAddInternal(key, value, true, true, out dummy);
        }
    }

If you notice the setter calls TryAddInternal which is thread safe implementation

Answer 2

It is thread-safe in the sense that the internal state of the ConcurrentDictionary will not be corrupted. This is the main guarantee offered by this class. So if you call foo[bar] = fiz from one thread and foo[bar] = biz from another thread concurrently, then either fiz or biz will be finally stored as a value of the key bar , provided that this key already existed in the collection (otherwise an exception will be thrown by both threads).

It's as if foo[bar] was a variable with a size of a native integer or smaller, for example short count; . It is safe to update this variable from multiple threads, in the sense that its internal bits will not be partially updated, and will always hold the last value assigned. If this guarantee is not enough for your program, if for example you want the count to hold something meaningful, like how many times has been updated, then you'll have to synchronize the access to this variable.

In the case of ConcurrentDictionary , if you want the foo[bar] to hold the value biz only if it was previously fiz , then this is not thread-safe: if (foo[bar] == fiz) foo[bar] = biz . You'll have to use the TryUpdate method: foo.TryUpdate(bar, biz, fiz) . Another case: if you want the foo[bar] to hold the value biz only if it was not previously fiz , then you are out of luck. The ConcurrentDictionary does not include a method that offers this guarantee. So you'll be forced to go back in using a Dictionary + manual synchronization.