Analyse von Singleton-Mustern und gängigen Schreibmethoden (Entwurfsmuster 01)

Stellt sicher, dass eine Klasse nur eine Instanz hat und stellt einen globalen Zugriffspunkt auf die Instanz bereit.

——„Entwurfsmuster“

Das Konzept des Singleton-Modus ist unten sehr einfach C# Am Beispiel der Sprache werden die Vor- und Nachteile gängiger Singleton-Schreibmethoden aufgeführt.

1. Einfache Implementierung

 public sealed class Singleton
    {
        static Singleton instance = null;

        public void Show()
        {
            Console.WriteLine(  "instance function");
        }
        private Singleton()
        {
        }

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

Kommentare:

Nicht sicher für Threads
Die Anforderungen werden in einem einzelnen Thread erfüllt
Vorteile:
Da sich die Instanz innerhalb der Instanzeigenschaftenmethode befindet Damit die Klasse zusätzliche Funktionen nutzen kann, führt
keine Instanziierung durch, bis das Objekt eine Instanz erfordert; dieser Ansatz wird „Lazy Instantiation“ genannt. Durch die verzögerte Instanziierung wird die unnötige Instanziierung von Singletons beim Start der Anwendung vermieden.

2. Thread-Sicherheit

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

        private Singleton()
        {
        }

        public static Singleton Instance
        {
            get
            {
                lock (padlock)
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }

                return instance;
            }
        }
    }

Kommentar:

Der Teil, der gleichzeitig gesperrt wurde Da ist nur ein Thread, der das Programm betreten kann
Die Objektinstanz wird von dem Thread erstellt, der zuerst eintritt
Die nachfolgenden Threads (Instanz == null) sind falsch, wenn Eingabe, nicht. Wird erneut Objektinstanzen erstellen
fügt zusätzlichen Overhead hinzu und verliert an Leistung

3. Doppelte Verriegelung

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

        private Singleton()
        {
        }

        public static Singleton Instance
        {
            get
            {
                if (instance == null)
                {
                    lock (padlock)
                    {
                        if (instance == null)
                        {
                            instance = new Singleton();
                        }
                    }
                }
                return instance;
            }
        }
    }

Kommentare:

Multi-Thread-sicher
Threads werden nicht jedes Mal gesperrt
Ermöglicht die Verzögerung der Instanziierung bis zum ersten Zugriff auf das Objekt

4. Statische Initialisierung

 public sealed class Singleton
    {
        private static readonly Singleton instance = null;
        static Singleton()
        {
            instance = new Singleton();
        }
        private Singleton()
        {
        }
        public static Singleton Instance
        {
            get
            {
                return instance;
            }
        }
    }

Kommentare:

Hängt von der Common Language Runtime ab, um die Variableninitialisierung zu handhaben
Öffentlich statisch Eigenschaften Bietet einen globalen Zugriffspunkt für den Zugriff auf Instanzen
Weniger Kontrolle über den Instanziierungsmechanismus (implementiert durch .NET)
Statische Initialisierung ist in .NET implementiert. Die bevorzugte Methode von Singleton

Kleiner Hinweis:

Statische Konstruktoren haben keine Zugriffsmodifikatoren, C# markiert sie automatisch als privat, der Grund dafür muss als privat markiert sein.

soll verhindern, dass der von Entwicklern geschriebene Code ihn aufruft Dies durch die CLR.

5. Verzögerte Initialisierung

public sealed class Singleton
    {
        private Singleton()
        {
        }
        public static Singleton Instance
        {
            get
            {
                return Nested.instance;
            }
        }

        public static void Hello()
        {
        }

        private class Nested
        {
            internal static readonly Singleton instance = null;
            static Nested()
            {
                instance = new Singleton();
            }
        }
    }

Kommentare:

Die Initialisierungsarbeit Dies geschieht durch die Verwendung eines statischen Mitglieds der Nested-Klasse, wodurch eine verzögerte Initialisierung erreicht wird.

Da der Zeitpunkt des Aufrufs statischer Funktionen der Zeitpunkt ist, an dem die Klasse instanziiert oder das statische Mitglied aufgerufen wird, Und das .net-Framework ruft den statischen Konstruktor auf, um die statischen Mitgliedsvariablen zu initialisieren, Wenn Sie es also gemäß der vierten Methode schreiben, wann Wenn die Hello-Methode erneut aufgerufen wird, wird eine Singleton-Instanz instanziiert. Dies ist nicht das, was wir sehen möchten, , da wir möglicherweise nur die Hello-Methode und nichts anderes verwenden möchten.

Hinweise:

1 Der Instanzkonstruktor im Singleton-Modus kann auf geschützt gesetzt werden, um die Ableitung von Unterklassen zu ermöglichen.
2. Der Singleton-Modus unterstützt die ICloneable-Schnittstelle im Allgemeinen nicht, da dies zu mehreren Objektinstanzen führen kann, was der ursprünglichen Absicht des Singleton-Modus widerspricht.
3. Der Singleton-Modus unterstützt im Allgemeinen keine Serialisierung, da dies auch zu mehreren Objektinstanzen führen kann, was ebenfalls der ursprünglichen Absicht des Singleton-Modus widerspricht.
4. Der Singletom-Modus berücksichtigt nur die Verwaltung der Objekterstellung, nicht jedoch die Verwaltung der Objektzerstörung. In Bezug auf Plattformen, die die Speicherbereinigung und den Overhead von Objekten unterstützen, müssen wir im Allgemeinen keine spezielle Verwaltung ihrer Zerstörung durchführen.

Zusammenfassung:

1 Muster schränken die Klassenerstellung ein, statt sie zu verbessern.
2. Der Kern des Verständnisses und der Erweiterung des Singleton-Musters besteht darin, „den willkürlichen Aufruf des Benutzers an den Konstruktor einer Klasse mithilfe von new zu steuern“.
3. Sie können einen Singleton leicht ändern, um einige Instanzen zu haben.

Das Obige ist der Inhalt des Singleton-Musters und der allgemeinen Schreibanalyse (Entwurfsmuster 01), mehr verwandt Bitte achten Sie hinsichtlich des Inhalts auf die chinesische PHP-Website (m.sbmmt.com)!