Le pattern Singleton

1. Contrôle d'accès unique : Le Singleton assure qu'une seule instance de la classe est créée dans l'ensemble du programme. Cela est souvent réalisé en cachant le constructeur de la classe pour empêcher la création d'objet par les méthodes habituelles.

1. Accès global : L'instance unique du Singleton est généralement accessible globalement, ce qui permet d'accéder facilement à l'instance sans avoir à la passer en tant que paramètre à travers l'application.

2. Initialisation paresseuse (Lazy Initialization) : Souvent, le Singleton est instancié lors de sa première utilisation, ce qui permet de réduire la charge de mémoire et d'améliorer les performances de l'application lors du démarrage.

Utilisations du Singleton

• Gestion des ressources : Pour gérer les accès à une ressource partagée dans une application, comme une connexion à une base de données ou un fichier de log.

• Configuration : Pour stocker la configuration de l'application que l'on souhaite accessible globalement sans avoir à instancier de multiples objets de configuration.

• Gestion de cache : Lorsqu'on a besoin d'un cache unique à travers l'application pour stocker et réutiliser des données coûteuses à obtenir.

• Gestion des drivers : Dans les systèmes où les drivers doivent être uniques, comme dans certaines applications matérielles ou de bas niveau.

Sont schémas UML

• Singleton Class : C'est la classe qui implémente le pattern Singleton. Elle contient une méthode statique (par exemple, getInstance()) qui permet d'accéder à l'unique instance de la classe. Le constructeur de cette classe est privé pour empêcher l'instanciation directe.

• Instance : Il s'agit de l'unique instance de la classe Singleton. Cette instance est privée et statique au sein de la classe Singleton.

• La méthode getInstance() retourne l'attribut instance cette méthode contrôle l'accès à l'instance de la classe Singleton.

• Le constructeur Singleton() est privé, ce qui empêche l'instanciation externe.

Exemple de code

Java

public class Singleton {
    private static Singleton instance;

    private Singleton() {}  // Constructeur privé pour empêcher l'instanciation

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

Python

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
            # Initialisation de l'instance peut être faite ici
        return cls._instance

# Utilisation du Singleton
singleton_instance = Singleton()
another_instance = Singleton()

# Ces deux instances sont en fait la même
assert singleton_instance is another_instance

Ruby

require 'singleton'

class SingletonExample
  include Singleton
end

instance = SingletonExample.instance
another_instance = SingletonExample.instance

# Ces deux instances sont identiques
puts instance == another_instance

Avantages et Inconvénients

• Assure qu'une classe n'a qu'une seule instance.

• Offre un point d'accès global à cette instance.

• Peut contribuer à économiser des ressources.

• Peut introduire un point de défaillance global dans l'application.

• L'usage global peut rendre les tests plus difficiles, car il introduit un état partagé entre les tests.

• Peut être difficile à utiliser dans un environnement multi-thread sans précautions supplémentaires pour assurer la thread-sécurité.