Est le C# '??' thread de l'opérateur en toute sécurité?

Question

Tout le monde sait que c'est pas thread-safe:

public StringBuilder Builder 
{ 
    get 
    { 
     if (_builder != null) 
      _builder = new StringBuilder(); 
     return _builder; 
    } 
} 

Qu'en est-ce?

public StringBuilder Builder 
{ 
    get { return _builder ?? (_builder = new StringBuilder()); } 
} 

Answer 1

BEGIN EDIT

Basé sur le titre édité, l'opérateur nul-coalescent lui-même semble être thread-safe (voir Phil Haack's analysis). Il semble, cependant, qu'il ne garantit pas contre les appels multiples potentiels au constructeur StringBuilder.

FIN EDIT

Vous avez un problème plus important avec filetage, et qui est que la propriété Builder lui-même représente l'état qui peut être partagé entre les threads. Même si vous sécurisez le thread d'initialisation paresseux, il n'y a aucune garantie que les méthodes consommant Builder le font d'une manière sûre pour les threads.

// below code makes the getter thread safe 
private object builderConstructionSynch = new object(); 
public StringBuilder Builder 
{ 
    get 
    { 
     lock (builderConstructionSynch) 
     { 
      if (_builder == null) _builder = new StringBuilder(); 
     } 
     return _builder; 
    } 
} 

La volonté ci-dessus éviter le problème de thread dans l'initialisation paresseuse de _builder, mais à moins que vous synchronisez vos appels à des méthodes d'instance de StringBuilder, vous n'êtes pas garanti la sécurité de fil dans toutes les méthodes qui consomment la propriété Builder. C'est parce que les méthodes d'instance dans StringBuilder n'ont pas été conçues pour être thread-safe. Voir le texte ci-dessous du MSDN StringBuilder page.

statiques publics (en Visual Basic) de ce type sont thread sûr. Tous les membres d'instance ne sont pas garanti être thread-safe.

Si vous consommez StringBuilder dans plusieurs threads, il est probablement préférable de l'encapsuler dans votre classe. Rendre privé et d'exposer Builder ce que le comportement dont vous avez besoin en tant que méthode publique:

public void AppendString(string toAppend) 
{ 
    lock (Builder) 
    { 
     Builder.Append(toAppend); 
    } 
} 

De cette façon, vous n'êtes pas à écrire du code de synchronisation dans tous les sens.

Answer 2

NO pour les deux versions

Answer 3

C'est plus ou moins thread-safe; vous pouvez toujours avoir deux threads faire la vérification nulle en même temps, donc créer des objets séparés et ne pas voir l'autre.

Answer 4

Non, ni sont atomiques

Answer 5

Les réponses données sont correctes, les deux ne sont pas ThreadSafe. En fait, ils sont pour la plupart équivalents, et l'opérateur ?? est juste un compilateur magique pour rendre le code plus léger. Vous devez utiliser un mécanisme de synchronisation si vous voulez que cela devienne threadsafe.

Answer 6

Je n'ai pas testé moi-même approche, mais si vous voulez la sécurité des threads sans la surcharge d'un système de verrouillage et vous n'êtes pas inquiet de ce qui pourrait créer et à rejeter une instance d'objet, vous pouvez essayer ceci:

using System.Threading; 

public StringBuilder Builder 
{ 
    get 
    { 
     if (_builder != null) 
      Interlocked.CompareExchange(ref _builder, new StringBuilder(), null); 
     return _builder; 
    } 
} 

L'appel à CompareExchange() effectuera un remplacement atomique de la valeur dans _builder avec une nouvelle instance de StringBuilder uniquement si _builder == null.Toutes les méthodes de la classe Interlocked sont garanties de ne pas être préemptées par les commutateurs de threads.