线程安全订阅列表的最佳数据结构？

Question

我正在尝试建立一个订阅列表。让我们举个例子：

出版商列表，每个出版商都有一个杂志列表，每个

杂志 都有一个订阅者列表杂志 -->订阅者

在 C# 中，在字典中使用字典是有意义的。在没有竞争条件的情况下添加/删除订阅者时，是否可以在不锁定整个结构的情况下执行此操作？

而且 C# 中的代码很快就会变得混乱，这让我觉得我没有走正确的道路。有没有更简单的方法来做到这一点？下面是构造函数和 subscribe 方法：

名称

注意：代码中使用了 Source、Type、Subscriber，而不是上面的Source ---> 。类型--->订户

public class SubscriptionCollection<SourceT, TypeT, SubscriberT>
{
// Race conditions here I'm sure! Not locking anything yet but should revisit at some point

ConcurrentDictionary<SourceT, ConcurrentDictionary<TypeT, ConcurrentDictionary<SubscriberT, SubscriptionInfo>>> SourceTypeSubs;

public SubscriptionCollection()
{
    SourceTypeSubs = new ConcurrentDictionary<SourceT, ConcurrentDictionary<TypeT, ConcurrentDictionary<SubscriberT, SubscriptionInfo>>>();
}

public void Subscribe(SourceT sourceT, TypeT typeT, SubscriberT subT) {

    ConcurrentDictionary<TypeT, ConcurrentDictionary<SubscriberT, SubscriptionInfo>> typesANDsubs;
    if (SourceTypeSubs.TryGetValue(sourceT, out typesANDsubs))
    {
        ConcurrentDictionary<SubscriberT, SubscriptionInfo> subs;
        if (typesANDsubs.TryGetValue(typeT, out subs))
        {

            SubscriptionInfo subInfo;
            if (subs.TryGetValue(subT, out subInfo))
            {
                // Subscription already exists - do nothing

            }
            else
            {
                subs.TryAdd(subT, new SubscriptionInfo());
            }
        }
        else
        {
            // This type does not exist - first add type, then subscription
            var newType = new ConcurrentDictionary<SubscriberT, SubscriptionInfo>();
            newType.TryAdd(subT, new SubscriptionInfo());
            typesANDsubs.TryAdd(typeT, newType);

        }

    }
    else
    {
        // this source does not exist - first add source, then type, then subscriptions
        var newSource = new ConcurrentDictionary<TypeT, ConcurrentDictionary<SubscriberT, SubscriptionInfo>>();
        var newType = new ConcurrentDictionary<SubscriberT, SubscriptionInfo>();
        newType.TryAdd(subT, new SubscriptionInfo());
        newSource.TryAdd(typeT, newType);
        SourceTypeSubs.TryAdd(sourceT, newSource);
    };
}

Answer 1

如果您使用 ConcurrentDictionary（就像您已经做的那样），则不需要锁定，这已经得到解决。

但你仍然需要考虑竞争条件以及如何处理它们。幸运的是，ConcurrentDictionary 可以满足您的需求。例如，如果您有两个线程，两者都尝试同时订阅尚不存在的源，则只有其中一个会成功。但这就是为什么 TryAdd() 返回添加是否成功的原因。你不能忽略它的返回值。如果它返回 false，您就知道其他线程已经添加了该源，因此您现在可以检索字典。

另一种选择是使用 GetOrAdd() 方法。它检索已经存在的值，如果尚不存在则创建它。

我会像这样重写你的代码（并使其变得更简单）：

public void Subscribe(SourceT sourceT, TypeT typeT, SubscriberT subT)
{
    var typesAndSubs = SourceTypeSubs.GetOrAdd(sourceT,
        _ => new ConcurrentDictionary<TypeT, ConcurrentDictionary<SubscriberT, SubscriptionInfo>>());

    var subs = typesAndSubs.GetOrAdd(typeT,
        _ => new ConcurrentDictionary<SubscriberT, SubscriptionInfo>());

    subs.GetOrAdd(subT, _ => new SubscriptionInfo());
}