Singleton (patron de conception)

Patron de conception
Un article de Wikipédia, l'encyclopédie libre.
(Redirigé depuis Design pattern)
Aller à : Navigation, Rechercher
En génie logiciel, un patron de conception (design pattern en anglais) est un concept destiné à
résoudre les problèmes récurrents suivant le paradigme objet. En français on utilise aussi le terme
motif de conception qui est une traduction alternative de «design pattern», perçue comme
incorrecte par certains.
Les patrons de conception décrivent des solutions standards pour répondre à des problèmes
d'architecture et de conception des logiciels. À la différence d'un algorithme qui s'attache à décrire
d'une manière formelle comment résoudre un problème particulier, les patrons de conception
décrivent des procédés de conception généraux. On peut considérer un patron de conception comme
une formalisation de bonnes pratiques, ce qui signifie qu'on privilégie les solutions éprouvées (un
patron de conception n'est considéré comme « prouvé » qu'une fois qu'il a été utilisé avec succès au
moins dans trois cas).
But général
[modifier]
Le but général des patrons de conception est de minimiser les interactions qu'il peut y avoir entre les
différentes classes (ou modules, plus généralement) d'un même programme. L'avantage de ces
patrons est de diminuer le temps nécessaire au développement d'un logiciel et d'augmenter la qualité
du résultat, notamment en appliquant des solutions déjà existantes à des problèmes courants de
conception. Ils sont là pour éviter la présence d'anti-patrons. Ils sont aussi utiles pour définir un
vocabulaire commun entre les différents acteurs de l'écriture d'un logiciel.
Ces patrons sont décrits sous une forme abstraite, sans s'attacher aux détails du problème à
résoudre.
Histoire
[modifier]
Formalisé dans le livre du « Gang of Four » (GoF, Erich Gamma, Richard Helm, Ralph Johnson et
John Vlissides) intitulé « Design Patterns -- Elements of Reusable Object-Oriented Software » (voir
bibliographie) en 1995, les patrons de conception tirent leur origine des travaux de l'architecte
Christopher Alexander dans les années 70.
Citations [modifier]
•
« Chaque patron décrit un problème qui se manifeste constamment dans notre
environnement, et donc décrit le cœur de la solution à ce problème, d’une façon telle que
l’on puisse réutiliser cette solution des millions de fois, sans jamais le faire deux fois de la
même manière » Christopher Alexander - 1977.
•
« Les patrons offrent la possibilité de capitaliser un savoir précieux né du savoir-faire
d’experts » [Buschmann] - 1996.
Singleton (patron de conception)
Un article de Wikipédia, l'encyclopédie libre.
En génie logiciel, le singleton est un patron de conception (design pattern) dont l'objet est de
restreindre l'instanciation d'une classe à un seul objet (ou bien quelques objets seulement). Il est
utilisé lorsque l'on a besoin d'exactement un objet pour coordonner des opérations dans un système.
Le modèle est parfois utilisé pour son efficacité, lorsque le système est plus rapide ou occupe moins
de mémoire avec peu d'objets qu'avec beaucoup d'objets similaires.
On implémente le singleton en écrivant une classe contenant une méthode qui crée une instance
uniquement s'il n'en existe pas encore. Sinon elle renvoie une référence vers l'objet qui existe déjà.
Dans beaucoup de langages de type objet, il faudra veiller à ce que le constructeur de la classe soit
privé ou bien protégé, afin de s'assurer que la classe ne puisse être instanciée autrement que par la
méthode de création contrôlée.
Le singleton doit être implémenté avec précaution dans les applications multi-thread. Si deux
threads exécutent en même temps la méthode de création alors que l'objet unique n'existe pas
encore, il faut absolument s'assurer qu'un seul créera l'objet, et que l'autre obtiendra une référence
vers ce nouvel objet.
La solution classique à ce problème consiste à utiliser l'exclusion mutuelle pour indiquer que l'objet
est en cours d'instanciation.
Java
[modifier]
Voici une solution écrite en Java (il faut écrire un code similaire pour chaque classe-singleton):
public class Singleton {
private static Singleton INSTANCE = null;
/**
* La présence d'un constructeur privé supprime
* le constructeur public par défaut.
*/
private Singleton() {}
/**
* Le mot-clé synchronized sur la méthode de création
* empêche toute instanciation multiple même par
* différents threads.
* Retourne l'instance du singleton.
*/
public synchronized static Singleton getInstance() {
if (INSTANCE == null)
INSTANCE = new Singleton();
return INSTANCE;
}
}
Une solution variante existe cependant. Elle consiste à alléger le travail de la méthode getInstance
en déplaçant la création de l'instance unique au niveau de la déclaration de la variable référant
l'instance unique:
public class Singleton {
/**
* Création de l'instance au niveau de la variable.
*/
private static final Singleton INSTANCE = new Singleton();
/**
* La présence d'un constructeur privé supprime
* le constructeur public par défaut.
*/
private Singleton() {}
/**
* Dans ce cas présent, le mot-clé synchronized n'est pas utile.
* L'unique instanciation du singleton se fait avant
* l'appel de la méthode getInstance(). Donc aucun risque d'accès concurrents.
* Retourne l'instance du singleton.
*/
public static Singleton getInstance() {
return INSTANCE;
}
}
static
Le caractère static d'un propriété (un attribut ou une méthode essentiellement) dénote une propriété
directement liée au module de classe dans lequel elle est définie. Dit autrement, une propriété
static n'est pas liée à une instance, et c'est pourquoi il est toujours préférable de la préfixer
explicitement par le nom de sa classe. Exemple :
...
double x = Math.PI * 2;
double y = -x;
...
double z = Math.abs(x);
...
PI est un attribut de classe (pas un attribut d'instance !), tout comme abs est une fonction utilitaire
du module java.lang.Math (le package java.lang étant le package par défaut, inutile de le déclarer).
La documentation de l'API nous confirme que ces propriétés sont bien libéllées static :
Figure 15. Exemple de propriétés liées à une classe (static)
Les propriétés static sont ordinairement initialisées par des instructions placées dans un bloc static,
équivalent des constructeurs d'objets. Les blocs static sont exécutés au chargement de la classe.
=> En mémoire il n'y a au plus qu'une "instance" d'un module de classe et 0 à n instances de cette
classe.