在这种情况下，线程安全是一个问题？

Question

我是否需要在字典的以下简单 getter 和 setter 中有一些线程安全机制？

如果需要，请提供 lock 和 ConcurrentDictionary 的示例。

    public virtual void Add(IFoo foo)
    {
        dictionary.Add(foo.name, foo);
    }

    public virtual IFoo Get(string name)
    {
        if (!dictionary.TryGetValue(name, out IFoo foo)) return null;
        return foo;
    }

    public virtual bool Has(string name)
    {
        return dictionary.TryGetValue(name, out IFoo foo);
    }

    public virtual IFoo Remove(string name)
    {
        if (dictionary.TryGetValue(name, out IFoo foo))
        {
            dictionary.Remove(name);
        }
        return foo;
    }

    protected readonly IDictionary<string, IFoo> dictionary = new Dictionary<string, IFoo>();

Answer 1

根据要求，这是一个使用锁的线程安全版本。您的 Add 方法可以调用 GetOrAdd 或 AddOrUpdate，具体取决于在发生争用时您想要“第一个获胜”还是“最后一个获胜”。

public virtual void Add(IFoo foo)
{
    AddOrUpdate(foo);   // If you want "last one wins"
    //GetOrAdd(foo);      // If you want "first one wins"
}

private virtual IFoo GetOrAdd(IFoo foo)
{
    lock(dictionary)
    {
        IFoo result;
        if (!dictionary.TryGetValue(foo.name, out result))
        {
            // Not in the dictionary; add it
            result = foo;
            dictionary.Add(foo.name, foo);
        }
        return result;
    }
}
public virtual void AddOrUpdate(IFoo foo)
{
    lock(dictionary)
    {
        // Last one wins and overwrites if there is a race-condition
        dictionary[foo.name] = foo;
    }
}

public virtual IFoo Get(string name)
{
    lock(dictionary)
    {
        IFoo foo;
        dictionary.TryGetValue(name, out foo);
        return foo; // will be null if TryGetValue returned false
    }
}

public virtual bool Has(string name)
{
    lock(dictionary)
    {
        return dictionary.ContainsKey(name);
    }
    // But there's no guarantee it's still there when this method returns
}

public virtual IFoo Remove(string name)
{
    lock (dictionary)
    {
        IFoo result;
        if (dictionary.TryGetValue(name, out result))
        {
            dictionary.Remove(name);
        }
        return result;
    }
}

// Dictionary should be private, not protected to be sure a derived
// class doesn't access it without using locks
private readonly IDictionary<string, IFoo> dictionary = new Dictionary<string, IFoo>();

这是一个带有 ConcurrentDictionary 的版本：

public virtual void Add(IFoo foo)
{
    AddOrUpdate(foo);   // If you want "last one wins"
    //GetOrAdd(foo);      // If you want "first one wins"
}

private virtual IFoo GetOrAdd(IFoo foo)
{
    return concurrentDictionary.GetOrAdd(foo.name, foo);
}
public virtual void AddOrUpdate(IFoo foo)
{
    concurrentDictionary[foo.name] = foo;
}

public virtual IFoo Get(string name)
{
    IFoo result;
    concurrentDictionary.TryGetValue(name, out result);
    return result; // will be null if TryGetValue returned false
}

public virtual bool Has(string name)
{
    return concurrentDictionary.ContainsKey(name);
    // But there's no guarantee it's still there when this method returns
}

public virtual IFoo Remove(string name)
{
    IFoo result;
    concurrentDictionary.TryRemove(name, out result);
    return result;
}

private readonly ConcurrentDictionary<string, IFoo> concurrentDictionary = new ConcurrentDictionary<string, IFoo>();

Answer 2

如果你的字典会被不同的线程访问，那么你应该阅读以下关于字典的内容：

只要不修改集合，字典可以同时支持多个阅读器。即便如此，通过集合进行枚举本质上不是线程安全的过程。在枚举与写访问竞争的极少数情况下，必须在整个枚举期间锁定集合。要允许集合被多个线程访问以进行读写，您必须实现自己的同步。

我建议使用ConcurrentDictionary<TKey, TValue>作为线程安全集合，它提供原子和线程安全的方法：

所有这些操作都是原子的，并且对于 ConcurrentDictionary 类上的所有其他操作都是线程安全的。唯一的例外是接受委托的方法，即 AddOrUpdate 和 GetOrAdd。

查看此链接：https://msdn.microsoft.com/en-us/library/dd287191(v=vs.110).aspx

您可以使用lock 语句而不是使用您自己的锁定代码 如果你想使用Dictionary来实现线程同步，请查看这个链接：https://msdn.microsoft.com/en-us/library/c5kehkcz.aspx