Keine Cache-Version

Caching deaktiviert Standardeinstellung für diese Seite:aktiviert (code LNG204)
Wenn die Anzeige zu langsam ist, können Sie den Benutzermodus deaktivieren, um die zwischengespeicherte Version anzuzeigen.

Le modèle singleton (Singleton Pattern)

Le singleton pattern selon l'ouvrage "Design Patterns: Elements of Reusable Object-Oriented Software" du GOF.

Intention du singleton

Le pattern singleton nous assure qu'une seule instance soit créée, et nous fournit un point d'accès vers elle.

Inhaltsverzeichnis Haut

Motivation du singleton

Quand nous utilisons certaines classes, il est important que nous puissions nous assurer qu'une seule instance sera créée. Par exemple, un seul fichier système peut être créé, ainsi qu'un seul gestionnaire de fenêtres.

Comment pouvons nous nous assurer qu'une classe n'a qu'une seule instance, et que cette dernière est aisément accessible ?

Nous pourions utiliser une variable globale pour accéder à l'objet, mais ce procédé ne nous protège pas contre les instanciations multiples de l'objet. Nous devons donc confier à la classe elle même la responsabilité d'assurer qu'une seule instance sera créée. La classe est la plus à même d'assurer l'unicité de l'instance en contrôlant l'accès aux demandes de créations, et elle peut nous fournir un moyen d'accès à cette instance. C'est le singleton pattern.

Inhaltsverzeichnis Haut

Indications d'utilisation du singleton

Le modèle singleton peut nous aider dans les cas suivants :

  • Si une seule instance de la classe doit être créée, et que cette dernière doit être accessible aux clients en un point bien déterminé.
  • Si nous devons étendre par dérivation en sous-classe (hériter), et si les clients peuvent utiliser une instance étendue sans devoir modifier leur code.

Inhaltsverzeichnis Haut

Structure du singleton

GOF Singleton Pattern

Inhaltsverzeichnis Haut

Constituants du singleton

  • Singleton

Le singleton définit une opération Instance ou getInstance, qui nous permet d'accéder à l'instance. L'opération Instance (ou getInstance) est une opération de classe (méthode de classe en Smalltalk, fonction membre statique en C++, méthode statique en Java).

Il peut avoir la charge de créer sa propre instance unique.

Inhaltsverzeichnis Haut

Collaborations du singleton

Nous ne pouvons accéder à l'instance du singleton que par le seul intermédiaire de l'opération Instance (ou getInstance) du singleton.

Inhaltsverzeichnis Haut

Conséquences du singleton

Avantages du singleton pattern :

Accès contrôlé à une instance unique. La classe Singleton possède le contrôle des accès car elle encapsule son unique instance. Il est possible d'effectuer tout les traitements désirés dans l'opération Instance (ou getInstance), par exemple compter le nombre d'accès à l'instance unique.

Réduction du namespace (l'espace de noms). L'utilisation du pattern singleton nous permet d'éviter de poluer le namespace avec des variables globales destinées à stocker des instances uniques.

Raffinement des opérations et de la représentation. La classe Singleton peut être sous-classée (étendue par dérivation), et nous pouvons aisément configurer une application avec une instance de cette classe étendue. Nous opuvons configurer l'application at run-time (à l'exécution) avec une instance de la classe que nous désirons.

Permet un nombre variable d'instances. Le pattern singleton nous facilite les modifications de notre stratégie en nous permettant plus d'une instance de la clase Singleton. De plus, nous pouvons utiliser la même approche pour contrôler le nombre d'instances utilisées par l'application. Seules les opérations qui garantissent l'accès à l'instance devront être adaptées.

Plus flexible par rapport aux opérations de classes.

Inhaltsverzeichnis Haut

Implémentation du singleton

Nous devons veiller aux points suivants lors de l'utilisation du pattern singleton :

Unicité d'une instance. Le moyen utilisé est de cacher l'opération de création de l'instance dans une opération de classe.

Dérivation de la classe Singleton. Nous pouvons utiliser différentes méthodes pour y parvenir :

  • La variable qui fait référence à l'instance du singleton est initialisée avec une instance de la sous-classe.
  • Implémenter l'opération d'accès à l'instance dans une classe supérieure (SingletonFactory).
  • Utilisation d'un registre de singletons.

Inhaltsverzeichnis Haut

Exemples de codes

  1. Object subclass: #Singleton
  2. instanceVariableNames: ''
  3. classVariableNames: 'UniqueInstance '
  4. poolDictionaries: ''
  5. category: 'Patterns-Examples'
  6. current
  7. UniqueInstance ifNil: [UniqueInstance := Singleton basicNew].
  8. ^UniqueInstance
  9. new
  10. self error: 'Use current to get an instance of Class ' , self name

Afin d'interdire la création d'instance, on redéfinit la méthode new qui déclenche une erreur :

  1. new
  2. UniqueInstance ifNil: [UniqueInstancennnnnbbsppppp := Singleton basicNew].
  3. ^UniqueInstance

  1. using System;
  2. class Singleton
  3. {
  4. // Fields
  5. private static Singleton instance;
  6. // Constructor
  7. protected Singleton() {}
  8. // Methods
  9. public static Singleton Instance()
  10. {
  11. // Uses "Lazy initialization"
  12. if( instance == null ){
  13. instance = new Singleton();
  14. }
  15. return instance;
  16. }
  17. }
  18. public class Client{
  19. public static void Main(){
  20. // Constructor is protected -- cannot use new
  21. Singleton s1 = Singleton.Instance();
  22. Singleton s2 = Singleton.Instance();
  23. if( s1 == s2 ){
  24. Console.WriteLine( "s1 and s2 use one single instance" );
  25. }
  26. }
  27. }

  1. public class Singleton {
  2. // Fields
  3. private static Singleton instance = null;
  4. // Constructor
  5. private Singleton() {}
  6. // Methods
  7. public static Singleton getInstance(){
  8. // Uses "Lazy initialization"
  9. if(instance==null){
  10. instance = new Singleton();
  11. }
  12. return instance;
  13. }
  14. }
  15. public class Launcher {
  16. public static void main(String[] args) {
  17. Singleton s1,s2;
  18. // Constructor is protected -- cannot use new
  19. s1 = Singleton.getInstance();
  20. s2 = Singleton.getInstance();
  21. if(s1 == s2){
  22. System.out.println("s1 and s2 use one single instance");
  23. }
  24. }
  25. }

Ce qui dans les deux cas doit afficher ceci à la console :

s1 and s2 use one single instance

... car une seule instance est créée, et la comparaison == teste qu'une seule adresse en mémoire est utilisée.

Inhaltsverzeichnis Haut

Remarques

Le modificateur de visibilité "private" est appliqué au constructeur, afin qu'il ne soit pas possible de créer une autre instance (new Singleton() ). L'usage du modificateur "protected" est cependant assez répendu, qui refuse l'accès au constructeur pour les autres classes, mais le permet pour les classes qui héritent de notre singleton.

public static Singleton getInstance() : la méthode est en "static" ce qui permet d'accéder à l'instance, car il n'est pas possible d'utiliser le constructeur.

Dans le cas d'utilisation de plusieurs threads, il est possible que ce type de mise en œuvre du pattern singleton (lazy initialisation) soit mis en défaut. Il est alors possible de contrer en utilisant le modificateur d'accès static :

  1. public class Singleton {
  2. // Fields
  3. private static Singleton instance = null;
  4. static{
  5. // Uses "Threadsafe initialization"
  6. instance = new Singleton();
  7. }
  8. // Constructor
  9. protected Singleton() {}
  10. // Methods
  11. public static Singleton getInstance(){
  12. return instance;
  13. }
  14. }

Inhaltsverzeichnis Haut

Patterns apparentés au singleton

De nombreux patterns peuvent être implémentés à l'aide du singleton (par exemple : AbstractFactory, Prototype, etc.).

Deutsche Übersetzung

Sie haben gebeten, diese Seite auf Deutsch zu besuchen. Momentan ist nur die Oberfläche übersetzt, aber noch nicht der gesamte Inhalt.

Wenn Sie mir bei Übersetzungen helfen wollen, ist Ihr Beitrag willkommen. Alles, was Sie tun müssen, ist, sich auf der Website zu registrieren und mir eine Nachricht zu schicken, in der Sie gebeten werden, Sie der Gruppe der Übersetzer hinzuzufügen, die Ihnen die Möglichkeit gibt, die gewünschten Seiten zu übersetzen. Ein Link am Ende jeder übersetzten Seite zeigt an, dass Sie der Übersetzer sind und einen Link zu Ihrem Profil haben.

Vielen Dank im Voraus.

Dokument erstellt 04/10/2005, zuletzt geändert 26/10/2018
Quelle des gedruckten Dokuments:https://www.gaudry.be/de/pattern-singleton.html

Die Infobro ist eine persönliche Seite, deren Inhalt in meiner alleinigen Verantwortung liegt. Der Text ist unter der CreativeCommons-Lizenz (BY-NC-SA) verfügbar. Weitere Informationen auf die Nutzungsbedingungen und dem Autor.