Le modèle singleton (Singleton Pattern)

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.

Table des matières 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.

Table des matières 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.

Table des matières Haut

Structure du singleton

Table des matières 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.

Table des matières 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.

Table des matières 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.

Table des matières 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.

Table des matières Haut

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: [UniqueInstancennnnnbbsppppp := 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.

Table des matières Haut

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

You are on the French version of the site, but your system indicates that you prefer to use the English language.
The entire site is not translated yet, but the menus and buttons on the interface are largely translated.

Would you like to reach the page in English?
Click here to continue in English: Consult the English version of this page

U bevindt zich op de Franse versie van de site, maar uw systeem geeft aan dat u liever de Nederlandse taal gebruikt.
De hele site is nog niet vertaald, maar de menu's en knoppen op de interface zijn grotendeels vertaald.

Wilt u de pagina in het Nederlands bereiken?
Klik hier om door te gaan in het Nederlands: Raadpleeg de Nederlandse versie van deze pagina

Sie befinden sich in der französischen Version der Website, Ihr System gibt jedoch an, dass Sie die deutsche Sprache bevorzugen.
Die gesamte Site ist noch nicht übersetzt, aber die Menüs und Schaltflächen auf der Benutzeroberfläche sind weitgehend übersetzt.

Möchten Sie die Seite auf Deutsch erreichen?
Klicken Sie hier, um fortzufahren: Konsultieren Sie die deutsche Version dieser Seite