Sperrung in .NET

Stieß ich auf diese Artikel Diskussion, warum das double-check-locking-Paradigma ist gebrochen in Java. Ist das Paradigma gültig .NET (insbesondere C#), wenn die Variablen deklariert sind volatile?

InformationsquelleAutor der Frage erikkallen | 2008-12-27

  1. 24

    Die Umsetzung des Singleton Pattern in C# spricht über dieses problem in der Dritten version.

    Er sagt:

    Machen die Instanz-variable volatile machen kann, es funktioniert, als würde die explizite memory-Barriere nennt, obwohl im letzteren Fall können selbst Experten nicht genau, welche Barrieren erforderlich. Ich Neige dazu, zu versuchen, Situationen zu vermeiden, in dem die Experten nicht darüber einig, was richtig und was falsch ist.

    Des Autors scheint zu implizieren, dass double-locking-ist wahrscheinlich weniger Arbeit als andere Strategien, und sollte daher nicht verwendet werden.

    InformationsquelleAutor der Antwort Cameron MacFarland

  2. 68

    Überprüfen locking funktioniert in Java sowie C# (Java-memory-Modell geändert und dies ist einer der Effekte). Jedoch, Sie haben, um es zu bekommen genau Recht. Wenn Sie Durcheinander zu bringen, noch leicht, kann man gut am Ende verlieren die thread-Sicherheit.

    Anderen Antworten gesagt haben, wenn Sie die Umsetzung der singleton-Muster es gibt viel bessere Möglichkeiten, es zu tun. Persönlich, wenn ich in eine situation, wo ich die Wahl zwischen double-checked-locking und "lock jedes mal" code würde ich gehen für die Verriegelung jedes mal, bis ich hättest wirklichen Beweise, dass es einen Engpass verursachen. Wenn es um Gewindeschneiden, eine einfache und natürlich-richtige Muster ist viel Wert.

    InformationsquelleAutor der Antwort Jon Skeet

  3. 20

    .NET 4.0 hat eine neue Art: Lazy<T> das nimmt jede Sorge darum, das Muster falsch. Es ist Teil der neuen Task Parallel Library.

    Finden Sie in der MSDN-Parallel-Computing-Dev-Center: http://msdn.microsoft.com/en-us/concurrency/default.aspx

    BTW, es gibt ein backport (ich glaube, es wird nicht unterstützt).NET 3.5 SP1 verfügbar hier.

    InformationsquelleAutor der Antwort David Messner

  4. 7

    Beachten als in Java (und wahrscheinlich auch in .Net so gut), double-checked-locking für singleton-Initialisierung ist völlig unnötig, so gut wie gebrochen. Da der Unterricht nicht initialisiert werden, bis Sie zum ersten mal eingesetzt, die gewünschte verzögerte Initialisierung ist bereits erreicht;

    private static Singleton instance = new Singleton();

    Sei denn, Ihr Singleton-Klasse enthält Sachen wie Konstanten, die zugegriffen werden kann, bevor eine Singleton-Instanz wird zunächst verwendet, das ist alles was Sie tun müssen.

    InformationsquelleAutor der Antwort Michael Borgwardt

  5. 2

    Habe ich bekommen, double-checked locking um die Arbeit mit boolean (d.h. mit einem primitiven zu vermeiden, die lazy-Initialisierung):

    Singleton mit boolean funktioniert nicht. Die Reihenfolge der Operationen, wie gesehen, zwischen verschiedenen threads ist nicht garantiert, es sei denn, Sie gehen durch eine memory-Barriere.
    In anderen Worten, wie man Sie auch aus einem zweiten thread
    created = true kann ausgeführt werden, bevor instance= new Singleton();

    InformationsquelleAutor der Antwort Dimafa

  6. 1

    Verstehe ich nicht, warum alle Menschen sagen, dass das double-check-locking-bad-Muster, aber sich nicht anpassen der code, damit es richtig funktioniert. Meiner Meinung nach, unter diesem code sollte gut funktionieren.

    Wenn jemand mir sagen könnte, ob dieser code leiden unter dem problem wissen in Camerons Artikel, bitte nicht.

    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;
        }
    }
}

    InformationsquelleAutor der Antwort M.Parent

  7. 0

    Ich verstehe nicht ganz, warum es gibt eine Menge der Implementierung der Muster auf double-checked locking (scheinbar zu umgehen compiler Eigenheiten in verschiedenen Sprachen). Der Wikipedia-Artikel zu diesem Thema zeigt die naive Methode und die Möglichkeiten, das problem zu lösen, aber keine sind so einfach wie diese (in 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;
    }
  }

    In Java, die Sie verwenden würden, synchronisiert() statt lock(), aber es ist im Grunde die gleiche Idee. Wenn es die möglich Inkonsistenz bei der singleton-Bereich zugewiesen bekommt, warum dann nicht einfach ein lokal gültigen erste variable, und weisen Sie die singleton-Feld an der letzten möglichen moment vor dem verlassen des kritischen Abschnitts? Bin ich etwas fehlt?

    Da ist das argument von @michael-borgwardt, die in C# und Java das statische Feld wird nur einmal initialisiert bei der ersten Verwendung, aber dass Verhalten, ist die Sprache spezifisch. Und ich habe dieses Muster, die Häufig für die verzögerte Initialisierung einer collection-Eigenschaft (z.B. Benutzer.Sitzungen).

    InformationsquelleAutor der Antwort Erhhung

  8. -5

    Habe ich bekommen, double-checked locking um die Arbeit mit boolean (d.h. mit einem primitiven zu vermeiden, die lazy-Initialisierung):

    private static Singleton instance;
private static boolean created;
public static Singleton getInstance() {
    if (!created) {
        synchronized (Singleton.class) {
            if (!created) {
                instance = new Singleton();
                created = true;
            }
        }
    }
    return instance;
}

    InformationsquelleAutor der Antwort Jono

Schreibe einen Kommentar