Le modèle singleton (Singleton Pattern)

Sommaire du document

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

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

Object subclass: #Singleton
instanceVariableNames: ''
classVariableNames: 'UniqueInstance '
poolDictionaries: ''
category: 'Patterns-Examples'
current
UniqueInstance ifNil: [UniqueInstance := Singleton basicNew].
^UniqueInstance
new
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 :

new
UniqueInstance ifNil: [UniqueInstance := Singleton basicNew].
^UniqueInstance

using System;
class Singleton
{
	// Fields
	private static Singleton instance;
	// Constructor
	protected Singleton() {}
	// Methods
	public static Singleton Instance()
	{
		// Uses "Lazy initialization"
		if( instance == null ){
			instance = new Singleton();
		}
		return instance;
	}
}
public class Client{
	public static void Main(){
		// Constructor is protected -- cannot use new
		Singleton s1 = Singleton.Instance();
		Singleton s2 = Singleton.Instance();
		if( s1 == s2 ){
			Console.WriteLine( "s1 and s2 use one single instance" );
		}
	}
}

public class Singleton {
	// Fields
	private static Singleton instance = null;
	// Constructor
	private Singleton() {}
	// Methods
	public static Singleton getInstance(){
		// Uses "Lazy initialization"
		if(instance==null){
			instance = new Singleton();
		}
		return instance;
		}
}
public class Launcher {
	public static void main(String[] args) {
		Singleton s1,s2;
		// Constructor is protected -- cannot use new
		s1 = Singleton.getInstance();
		s2 = Singleton.getInstance();
		if(s1 == s2){
			System.out.println("s1 and s2 use one single instance");
		}
	}
}

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 :

public class Singleton {
	// Fields
	private static Singleton instance = null;
	static{
		// Uses "Threadsafe initialization"
		instance = new Singleton();
	}
	// Constructor
	protected Singleton() {}
	// Methods
	public static Singleton getInstance(){
		return instance;
	}
}

Patterns apparentés au singleton

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

Expériences des broliens...

class MaClasse
{
 	private static $instance = NULL;
 
	private function __construct()
 	{
 		// initialisations ici
 	}
 
 	public static function getSingleton()
 	{
 		if (self::$instance == NULL) {
 			self::$instance = new MaClasse();
 		}
 
 		return self::$instance;
 	}
}

Liste des images

1. GOF Singleton Pattern _{(Référence : infobrol)}

Structure du document