Est-ce qu'un booléen en lecture/écriture atomique en C#

Question

accède à un bouffon champ atomique en C# ?En particulier, dois-je verrouiller :

class Foo
{
   private bool _bar;

   //... in some function on any thread (or many threads)
   _bar = true;

   //... same for a read
   if (_bar) { ... }
}

Answer 1

Oui.

Les lectures et écritures des types de données suivants sont atomiques :Types bool, char, byte, sbyte, short, ushort, uint, int, float et référence.

comme on le trouve dans Spécification du langage C#.

Modifier:Cela vaut probablement aussi la peine de comprendre le volatil mot-clé.

Answer 2

Comme indiqué ci-dessus, bool est atomique, mais vous devez quand même vous rappeler que cela dépend aussi de ce que vous voulez en faire.

if(b == false)
{
    //do something
}

n'est pas une opération atomique signifiant que la valeur B pourrait changer avant que le thread actuel exécute le code après l'instruction IF.

Answer 3

les accès booléens sont en effet atomiques, mais ce n'est pas toute l'histoire.

Vous n'avez pas à vous soucier de lire une valeur "incomplètement écrite" - de toute façon, ce que cela pourrait signifier pour un booléen n'est pas clair - mais vous devez vous soucier des caches du processeur, du moins si les détails de le timing est un problème.Si le thread n°1 exécuté sur le noyau A a votre _bar en cache, et _bar est mis à jour par le thread n°2 exécuté sur un autre noyau, le thread n°1 ne verra pas le changement immédiatement à moins que vous n'ajoutiez un verrouillage, déclarez _bar comme volatile, ou insérez explicitement des appels à Thread.MemoryBarrier() pour invalider la valeur mise en cache.

Answer 4

l'approche que j'ai utilisée, et je pense qu'elle est correcte, est

volatile bool b = false;

.. rarely signal an update with a large state change...

lock b_lock
{
  b = true;
  //other;
}

... another thread ...

if(b)
{
    lock b_lock
    {
       if(b)
       {
           //other stuff
           b = false;
       }
     }
}

le but était essentiellement d'éviter d'avoir à verrouiller un objet de manière répétitive à chaque itération juste pour vérifier si nous avions besoin de le verrouiller afin de fournir une grande quantité d'informations sur les changements d'état, ce qui se produit rarement.je pense cette approche fonctionne.Et si une cohérence absolue est requise, je pense volatile serait approprié sur le b bool.