Comment implémenter un HashSet simultané dans le .NET Framework ?

Implémentation de HashSet simultané dans .NET Framework ?

Introduction :

Le .NET Framework ne fournit pas d'implémentation intégrée d'un HashSet simultané, ce qui peut constituer un défi pour les développeurs travaillant avec des structures de données simultanées. Cet article explore la nécessité d'un HashSet simultané et examine différentes manières d'implémenter un accès thread-safe à HashSet dans le .NET Framework.

Implémentation de la sécurité des threads personnalisés :

Une approche consiste à créer une implémentation personnalisée de HashSet thread-safe. Ceci peut être réalisé en encapsulant un HashSet existant dans un mécanisme de synchronisation (tel qu'un verrou). L'extrait de code suivant illustre cette implémentation :

public class ConcurrentHashSet<T>
{
    private readonly HashSet<T> _hashSet = new HashSet<T>();
    private readonly object _syncRoot = new object();

    public bool Add(T item)
    {
        lock (_syncRoot)
        {
            return _hashSet.Add(item);
        }
    }

    public bool Remove(T item)
    {
        lock (_syncRoot)
        {
            return _hashSet.Remove(item);
        }
    }

    // 其他操作可以类似地实现
}

Utiliser ConcurrentDictionary :

Une autre approche consiste à utiliser la classe ConcurrentDictionary Bien qu'il ne fournisse pas exactement les mêmes fonctionnalités que HashSet, il fournit un dictionnaire thread-safe avec une sémantique similaire. En utilisant des paires clé-valeur (où les clés sont des éléments dans un HashSet et les valeurs sont des valeurs factices), nous pouvons réaliser une implémentation simultanée :

private ConcurrentDictionary<T, byte> _concurrentDictionary = new ConcurrentDictionary<T, byte>();

public bool Add(T item)
{
    byte dummyValue = 0;
    return _concurrentDictionary.TryAdd(item, dummyValue);
}

public bool Remove(T item)
{
    byte dummyValue;
    return _concurrentDictionary.TryRemove(item, out dummyValue);
}

// 其他操作可以类似地实现

Remarque :

Lors du choix d'une méthode, tenez compte des facteurs suivants :

• Sécurité de la concurrence : Les deux méthodes fournissent un accès thread-safe aux structures de données sous-jacentes.
• Performances : Dans certains cas, une implémentation personnalisée peut avoir de meilleures performances que ConcurrentDictionary.
• Simplicité : ConcurrentDictionary fournit une implémentation plus simple et plus directe.
Applicabilité de
• HashSet : ConcurrentDictionary n'hérite pas de HashSet, donc certaines fonctionnalités spécifiques à HashSet peuvent être perdues.

Conclusion :

Le besoin de HashSets simultanés dans le .NET Framework peut être résolu en implémentant un wrapper thread-safe personnalisé ou en utilisant ConcurrentDictionary. Le choix entre les deux dépend des exigences spécifiques de l’application et des compromis mentionnés ci-dessus.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!