# Singleton (patron de conception)

En génie logiciel, le singleton est un patron de conception (design pattern), appartenant à la catégorie des patrons de création, dont l'objectif est de restreindre l'instanciation d'une classe à un seul objet. On fournira alors un accès global à celui-ci. Il s'agit d'un des patrons de création les plus simples mais les plus couramment utilisés.
Il est utilisé lorsqu'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 un seul objet qu'avec beaucoup d'objets similaires.

## Principe

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é, 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.

## Implémentations
### D

Voici une class template écrite en D du pattern singleton :

### Java

Voici une solution écrite en Java (il faut écrire un code similaire pour chaque classe singleton) :
Pour plus d'information, sur ce patron : Cf The "Double-Checked Locking is Broken" Declaration.
Attention, l'usage du double checked locking est une mauvaise idée en Java. Ça ne fonctionne simplement pas dans un environnement multithread. Idem pour « volatile ».
Exemple d'utilisation :
Il est à noter que l'usage du pattern singleton en Java n'est pas des plus approprié car l’instanciation tardive de la classe que l'on cherche à obtenir est en fait le comportement par défaut du Java et le pattern "standard" risque juste de générer des bugs et des complications. En effet le ClassLoader de la JVM va charger les classes à la première utilisation et donc :
* Le mutex (la variable du synchronized) quel qu'il soit est créé à ce moment et donc est très artificiel ;
* La classe est nativement un singleton sur lequel il est naturel de s’appuyer.
À partir de cette remarque plusieurs implémentations sont possibles :
* Initialisation directe de la variable instance.
* Initialisation dans un bloc "static".
* Utilisation d'un "enum" à la place d'une classe.
L'utilisation se fait par appel de la seule valeur de l'enum :
Cette dernière forme est fortement recommandée depuis Java 1.5$^,$, mais l'utilisation d'une énumération étant gourmande, ce n'est donc pas l'idéal si le but recherché est la performance.
À noter que l'unicité du singleton est dépendante de l'unicité du ClassLoader.

### C++

Voici une implémentation possible en C++, connue sous le nom de singleton de Meyers. Le singleton est un objet static et local. Attention : cette solution n'est pas sûre dans un contexte multi-thread jusqu'en C++11 ; elle sert plutôt à donner une idée du fonctionnement d'un singleton qu'à être réellement utilisée dans un grand projet logiciel. Aucun constructeur ou destructeur ne doit être public dans les classes qui héritent du singleton.
Dans un langage à base de prototypes, où sont utilisés des objets mais pas des classes, un singleton désigne seulement un objet qui n'a pas de copies, et qui n'est pas utilisé comme prototype pour d'autres objets.
Une autre façon de voir les choses est de mettre un booléen en statique dans la classe, qui indique si une instance est déjà créée, et de refuser la création si c'est le cas :
Cette méthode permet aussi de limiter un nombre d'instances, en remplaçant le booléen par un nombre, et le test par une comparaison.

### Eiffel

Voici une classe Eiffel utilisant le pattern singleton :

### ActionScript 3

Une autre implémentation du singleton en AS3 qui prend en compte les spécificités du langage et surtout la définition du pattern
Déclaration d'une constante de type SingletonImpl :
L'implémentation proprement dite du Singleton :
Son utilisation est plutôt simple :

### Python
#### Implémentation simple

Les deux variables référencent ici la même instance. Cette solution ne nécessite pas de méthode spécifique pour accéder à l'instance de classe (comparativement à d'autres langages, où il est d'usage d'implémenter une méthode getInstance, par exemple).

#### Considérations avancées

D'après le développeur Python Alex Martelli, le patron de conception Singleton a un nom élégant mais trompeur, car il met l'accent sur l'identité plutôt que sur l'état de l'objet. D'où l'apparition d'un patron alternatif, appelé Borg, pour lequel toutes les instances partagent le même état. Il est généralement accepté par la communauté de développeurs Python que le partage d'état entre instances est plus élégant que la mise en cache de la création d'instances identiques lors de l'initialisation de la classe.
L'implémentation de cet état partagé est quasiment transparente en Python :
L'implémentation ci-dessus peut être améliorée en tirant parti du nouveau type de classe de Python, ne nécessitant ainsi qu'une seule instance :
* La méthode __init__ est exécutée pour chaque appel à Singleton ;
* Afin de permettre à une classe d'hériter d'un Singleton, la variable de classe instance devrait être un dictionnaire Python appartenant explicitement à la classe Singleton, comme illustré ci-dessous :

### Ruby

Le patron singleton existe dans la bibliothèque standard du langage Ruby. C'est un mixin qu'il suffit d'inclure dans la classe qui doit être un singleton.
La sortie de ce script est « foo ».

### PHP 5

Voici une solution écrite en PHP :
Il faut noter qu'avant PHP 5.3, il n'est pas possible d'hériter une classe de type Singleton. En effet, l'accesseur self:: se réfère toujours à la classe dans laquelle il est écrit.
Depuis PHP 5.3, la classe suivante fonctionne et est héritable :
Il est aussi possible d'utiliser static::, bien plus adapté.

### Perl

Pour les versions de Perl à partir de 5.10, une variable d'état fait l'affaire.
Pour les versions plus anciennes, c'est une fermeture qui fera l'affaire.
Si le module Moose est utilisé, il y a l'extension MooseX::Singleton