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.

 

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.

 

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.

 

Structure du singleton

GOF Singleton Pattern

 

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.

 

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.

 

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.

 

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.

 

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 :


Code SmallTalk (new) (3 lignes) :
  1. new
  2. UniqueInstance ifNil: [UniqueInstance := 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.

 

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

 

Patterns apparentés au singleton

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

 

Document créé le 04/10/05 21:04, dernière modification le 18/07/17 09:01
Source du document imprimé : https://www.gaudry.be/pattern-singleton.html

L'infobrol est un site personnel dont le contenu n'engage que moi. Le texte est mis à disposition sous licence CreativeCommons(BY-NC-SA). Plus d'info sur les conditions d'utilisation et sur l'auteur.