Double-vérifier le verrouillage dans .NET

La mise en œuvre de Singleton en C# parle de ce problème dans la troisième version.

Il dit:

Prise de la variable d'instance volatils pouvez le faire fonctionner, comme le ferait explicite barrière de mémoire les appels, bien que dans ce dernier cas, même les experts ne s'entendent pas exactement quels sont les obstacles nécessaires. J'ai tendance à essayer d'éviter les situations où les experts ne s'entendent pas ce qui est droit et ce qui est mal!

L'auteur semble sous-entendre que la double verrouillage est moins susceptibles de travailler que les autres stratégies et ne devraient donc pas être utilisés.

.NET 4.0 dispose d'un nouveau type: Lazy<T> qui enlève toute préoccupation au sujet d'obtenir le modèle de mal. Il fait partie de la nouvelle Task Parallel Library.

Consultez le site web MSDN de Calcul Parallèle Dev Center: http://msdn.microsoft.com/en-us/concurrency/default.aspx

BTW, il y a un backport (je crois que c'est pas pris en charge) pour .NET 3.5 SP1 disponible ici.

Je ne comprends pas pourquoi tous les gens dit que le double-vérifier le verrouillage est mauvais modèle, mais ne pas adapter le code pour qu'il fonctionne correctement. À mon avis, ce code ci-dessous devrait fonctionner parfaitement.

Si quelqu'un pouvait me dire si ce code souffrent du problème mentionné dans Cameron article, s'il vous plaît.

public sealed class Singleton {
    static Singleton instance = null;
    static readonly object padlock = new object();

    Singleton() {
    }

    public static Singleton Instance {
        get {
            if (instance != null) {
                return instance;
            }

            lock (padlock) {
                if (instance != null) {
                    return instance;
                }

                tempInstance = new Singleton();

                //initialize the object with data

                instance = tempInstance;
            }
            return instance;
        }
    }
}

Je n'arrive pas à comprendre pourquoi il y a un tas de mise en œuvre des schémas sur un double contrôle de verrouillage (apparemment pour contourner compilateur particularités dans différentes langues). L'article de Wikipedia sur ce sujet montre que la méthode naïve et les moyens possibles pour résoudre le problème, mais aucun n'est aussi simple que cela (en C#):

public class Foo
{
  static Foo _singleton = null;
  static object _singletonLock = new object();

  public static Foo Singleton
  {
    get
    {
      if ( _singleton == null )
        lock ( _singletonLock )
          if ( _singleton == null )
          {
            Foo foo = new Foo();

            //Do possibly lengthy initialization,
            //but make sure the initialization
            //chain doesn't invoke Foo.Singleton.
            foo.Initialize();

            //_singleton remains null until
            //object construction is done.
            _singleton = foo;
          }
      return _singleton;
    }
  }

En Java, vous pouvez utiliser synchronisée() à la place de la serrure(), mais c'est un peu la même idée. Si il y a la possible incompatibilité de quand le singleton champ est affectée, alors pourquoi ne pas utiliser un localement étendue variable d'abord et ensuite affecter le singleton champ au dernier moment avant la sortie de la section critique? Ai-je raté quelque chose?

Il y a l'argument par @michael-borgwardt qu'en C# et Java de la statique du champ est initialisé une fois lors de la première utilisation, mais que comportement est spécifique à une langue. Et j'ai utilisé ce modèle fréquemment pour les paresseux de l'initialisation d'une collection de propriété (par exemple, utilisateur.Les Sessions).