Utilisez la fonction de verrouillage sur la clé d'un Dictionnaire<string, object>

De verrouillage sur un objet qui est accessible de l'extérieur de la code de verrouillage, c'est un gros risque. Si un autre code (n'importe où) jamais les verrous de cet objet, vous pourriez être dans certains blocages qui sont difficiles à déboguer. Notez également que vous pouvez verrouiller la objet, pas la référence, donc, si je vous ai donné un dictionnaire, je peut encore contenir des références aux touches et verrouillage sur eux - ce qui nous pousse à verrou sur le même objet.

Si vous encapsuler complètement le dictionnaire, et de générer les clés vous-même (ils ne sont pas toujours transmis, alors vous pouvez être sûr.

Cependant, essayez de vous en tenir à une règle de limiter la visibilité de l'objet de verrouillage sur le code de verrouillage lui-même chaque fois que possible.

C'est pourquoi vous voyez ceci:

public class Something
{
  private readonly object lockObj = new object();

  public SomethingReentrant()
  {
    lock(lockObj)    //Line A
    {
      //...
     }
   }
}

plutôt que de les voir ligne ci-dessus remplacé par

  lock(this)

De cette façon, un objet est verrouillé, et que la visibilité est limitée.

Modifier Jon Skeet correctement observé que lockObj ci-dessus doivent être en lecture seule.

OriginalL'auteur Philip Rieck

Remarque: je suppose exception lors de la modification de la collecte au cours d'une itération est déjà fixé

Dictionnaire n'est pas thread-safe collection, ce qui signifie qu'il est pas sûr de modifier et de lire la collecte de différents threads sans synchronisation externe. Table de hachage est (était?) "thread-safe" pour un écrivain de nombreux lecteurs de scénario, mais le Dictionnaire est différente de la structure de données interne et ne pas hériter de cette garantie.

Cela signifie que vous ne pouvez pas modifier votre dictionnaire pendant que vous y accéder pour lire ou d'écrire à partir de l'autre fil, il peut juste cassé les structures de données internes. Le verrouillage de la clé n'est pas de protéger la structure de données interne, parce que pendant que vous modifiez cette clé, quelqu'un pourrait être la lecture de différentes clés de votre dictionnaire dans un autre thread. Même si vous pouvez garantir que tous vos clés sont les mêmes objets (comme dit sur la chaîne de stage), cela ne vous apportera pas sur le côté sécuritaire. Exemple:

1. Vous de verrouillage de la clé et de commencer à modifier le dictionnaire
2. Un autre thread tente d'obtenir la valeur de la clé qui se trouve à tomber dans le même seau comme bloqué. Ce n'est pas seulement quand hashcodes de deux objets sont les mêmes, mais le plus souvent quand hashcode%taille_table est le même.
3. Les deux threads accèdent à la même seau (liste liée de touches avec le même hashcode%taille_table valeur)

Si ce n'est pas la clé dans le dictionnaire, le premier thread va commencer à modifier la liste, et le second thread susceptibles de lecture incomplète de l'état.

Si cette clé existe déjà, détails de mise en œuvre de dictionnaire peut toujours modifier la structure de données, par exemple déplacer récemment accédé à touches à la tête de la liste pour une récupération plus rapide. Vous ne pouvez pas compter sur les détails d'implémentation.

Il y a beaucoup de cas comme ça, quand tu aura corrompu dictionnaire. Donc, vous devez avoir la synchronisation externe de l'objet (ou de l'utilisation du Dictionnaire lui-même, si elle n'est pas exposée au public) et le verrouiller sur elle pendant toute l'opération. Si vous avez besoin de plus granulaire de verrouillage lors de l'opération peut prendre un certain temps long, vous pouvez copier les touches dont vous avez besoin pour mettre à jour, de parcourir, de le verrouiller en totalité du dictionnaire lors de la clé de mise à jour (n'oubliez pas de vérifier la clé est toujours là) et le relâcher pour laisser les autres threads s'exécutent.

OriginalL'auteur Ilya Ryzhenkov

Viens de tomber sur ce et de la pensée de l'id de partager un peu de code que j'ai écrit il y a quelques années où j'avais besoin d'un dictionnaire sur une base clés en

 using (var lockObject = new Lock(hashedCacheID))
 {
    var lockedKey = lockObject.GetLock();
    //now do something with the dictionary
 }

la serrure de la classe

class Lock : IDisposable
    {
        private static readonly Dictionary<string, string> Lockedkeys = new Dictionary<string, string>();

        private static readonly object CritialLock = new object();

        private readonly string _key;
        private bool _isLocked;

        public Lock(string key)
        {
            _key = key;

            lock (CritialLock)
            {
                //if the dictionary doesnt contain the key add it
                if (!Lockedkeys.ContainsKey(key))
                {
                    Lockedkeys.Add(key, String.Copy(key)); //enusre that the two objects have different references
                }
            }
        }

        public string GetLock()
        {
            var key = Lockedkeys[_key];

            if (!_isLocked)
            {
                Monitor.Enter(key);
            }
            _isLocked = true;

            return key;
        }

        public void Dispose()
        {
            var key = Lockedkeys[_key];

            if (_isLocked)
            {
                Monitor.Exit(key);
            }
            _isLocked = false;
        }
    }

OriginalL'auteur Mark

Je peux en voir quelques-uns des problèmes potentiels:

1. chaînes de caractères peuvent être partagés, de sorte que vous ne savent pas forcément qui d'autre pourrait être de verrouillage sur la clé de l'objet pour quelle autre raison
2. des chaînes peuvent pas être partagé: vous avez peut-être de verrouillage sur l'une de clés de la chaîne de valeur "Key1" et quelque autre morceau de code peut avoir un autre objet de type string qui contient également les caractères "Key1". Pour le dictionnaire, ils sont de la même clé, mais aussi loin que le verrouillage est concerné, ils sont différents objets.
3. Que le verrouillage ne l'empêchera pas de changements à la valeur des objets eux-mêmes, c'est à dire matrixElements[someKey].ChangeAllYourContents()

OriginalL'auteur babackman