Patrons de conception/Singleton

En génie logiciel, le singleton est un modèle de conception (design pattern) dont le but 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 efficience, lorsque le système est plus rapide ou occupe moins de mémoire avec peu d'objets qu'avec beaucoup d'objets similiaires.

On implante le modè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 à objets, il faudra veiller à ce que le constructeur de la classe soit privé ou bien protégé, afin de s'assurer que la classe ne peut être instanciée autrement que par la méthode de création contrôlée.

Le modèle singleton doit être implanté 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.

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
    private synchronized static void createInstance() {
        if (INSTANCE == null) { 
            INSTANCE = new Singleton();
        }
    }

    public static Singleton getInstance() {
        if (INSTANCE == null) createInstance();
        return INSTANCE;
    }
}

Voici une implantation 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; elle sert plutôt à donner une idée du fonctionnement d'un singleton qu'à être réellement utilisée dans un grand projet logiciel.

template<typename T> class Singleton
{

  public:
    static T& Instance()
    {
        static T theSingleInstance; // suppose que T a un constructeur par défaut
        return theSingleInstance;
    }
};

class OnlyOne : public Singleton<OnlyOne>
{
    //...définir ici le reste de l'interface
};

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.