Analyse du modèle singleton et des méthodes d'écriture courantes (design pattern 01)

Garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global à l'instance.

——"Modèle de conception"

Le concept du mode singleton est très simple. C# En utilisant le langage comme exemple, les avantages et les inconvénients des méthodes d'écriture singleton courantes sont répertoriés.

1. Mise en œuvre simple

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

Commentaires :

Non sûr pour les threads
Les exigences sont remplies dans un seul thread
Avantages :
Puisque l'instance se trouve à l'intérieur de la méthode de propriété Instance Créée pour que la classe puisse utiliser des fonctionnalités supplémentaires
n'effectue pas d'instanciation tant que l'objet n'a pas besoin d'une instance ; cette approche est appelée "instanciation paresseuse". L'instanciation paresseuse évite l'instanciation inutile de singletons au démarrage de l'application.

2. Sécurité des fils

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

Commentaire :

La partie qui était verrouillée en même temps Là il n'y a qu'un seul thread qui peut entrer dans le programme
L'instance d'objet est créée par le thread qui entre en premier
Les threads suivants (instance == null) sont faux lorsque entrer, ne créera pas à nouveau des instances d'objet
ajoute une surcharge supplémentaire et perd en performances

3. Double verrouillage

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

Commentaires :

Coffre-fort multithread
Les threads ne sont pas verrouillés à chaque fois
Permet de retarder l'instanciation jusqu'au premier accès à l'objet

4. Initialisation statique

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

Commentaires :

Dépend du Common Language Runtime pour gérer l'initialisation des variables
Statique publique propriétés Fournit un point d'accès global pour accéder aux instances
Moins de contrôle sur le mécanisme d'instanciation (implémenté par .NET)
L'initialisation statique est implémentée dans .NET La méthode préférée de Singleton

Petite note :

Les constructeurs statiques n'ont ni modificateurs d'accès, C# les marquera automatiquement comme privés, raison pour laquelle doit être marqué comme privé,

est d'empêcher le code écrit par les développeurs de l'appeler. L'appel à celui-ci est toujours responsable de. ceci par le CLR.

5. Initialisation retardée

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

Commentaires :

Le travail d'initialisation se fait par Ceci est fait en utilisant un membre statique de la classe Nested, réalisant ainsi une initialisation paresseuse.

Parce que le moment de l'appel des fonctions statiques correspond au moment où la classe est instanciée ou où le membre statique est appelé, Et le framework .net appelle le constructeur statique pour initialiser les variables membres statiques, Donc, si vous l'écrivez selon la quatrième méthode, Quand la méthode Hello est appelée à nouveau, une instance Singleton sera instanciée. Ce n'est pas ce que nous voulons voir, car nous pouvons simplement vouloir utiliser la méthode Hello et rien d'autre.

Remarques :

1. Le constructeur d'instance en mode Singleton peut être défini sur protégé pour permettre la dérivation de sous-classe.
2. Le mode Singleton ne prend généralement pas en charge l'interface ICloneable, car cela peut conduire à plusieurs instances d'objet, ce qui est contraire à l'intention initiale du mode Singleton.
3. Le mode Singleton ne prend généralement pas en charge la sérialisation, car cela peut également conduire à plusieurs instances d'objet, ce qui est également contraire à l'intention initiale du mode Singleton.
4. Le mode Singletom ne prend en compte que la gestion de la création d'objets, mais ne considère pas la gestion de la destruction d'objets. En ce qui concerne les plates-formes prenant en charge le garbage collection et la surcharge des objets, nous n'avons généralement pas besoin d'effectuer une gestion particulière de leur destruction.

Résumé :

1. Les modèles limitent plutôt qu’améliorent la création de classes.
2. Le cœur de la compréhension et de l'extension du modèle Singleton est "comment contrôler l'appel arbitraire de l'utilisateur au constructeur d'une classe en utilisant new".
3. Vous pouvez facilement modifier un Singleton pour avoir quelques instances. Ceci est autorisé et significatif.

Ce qui précède est le contenu du modèle singleton et de l'analyse d'écriture commune (modèle de conception 01), plus liés Veuillez faire attention au site Web PHP chinois (www.php.cn) pour le contenu !