Le modèle singleton est l'un des modèles de conception les plus simples. Une classe qui utilise le modèle de conception singleton a une seule instance qu'elle gère elle-même. Cette classe empêche toute autre classe d'en créer une instance.
Une classe singleton fournit également un point d'accès global unique à l'instance qu'elle crée. Ainsi, toute classe qui souhaite une instance d'une classe singleton doit y accéder via son point d'accès unique.
L'excellent support de Java pour la programmation orientée objet facilite l'utilisation du modèle de conception singleton.
Implémentation du modèle Singleton à l'aide de Java
Il existe de nombreuses façons d'implémenter le modèle singleton en Java; les approches impatientes et paresseuses sont des variations courantes. Chacune de ces approches a ses avantages et ses inconvénients. Par conséquent, la méthode que vous choisissez d'employer doit dépendre du fonctionnement de votre application.
L'approche enthousiaste
L'implémentation du modèle singleton avec l'approche impatiente signifie que la classe crée une nouvelle instance d'elle-même lorsqu'elle se charge.
publicclasseDésireuxSingleton{
privéstatique Instance EagerSingleton = nouveau DésireuxSingleton();privéDésireuxSingleton(){}
publicstatique DésireuxSingleton getInstance(){
retour exemple;
}
}
Le DésireuxSingletonClasse Java crée une nouvelle instance de lui-même lors de son chargement. Il attribue cette instance au statique privé variable d'instance, qui n'est accessible qu'au sein de la classe singleton. Le seul point d'accès externe à la variable d'instance est via le getInstance() méthode. Cette méthode renvoie l'instance précédemment créée de la classe.
Cette approche est excellente car elle empêche le multithreading problème, qui est l'un des plus grands défis du modèle singleton. Il résout le problème du multithreading en créant une nouvelle instance de lui-même avant qu'un nouveau thread ne puisse accéder à sa variable d'instance. Cela garantit que chaque thread n'aura accès qu'à la même instance.
Cependant, l'approche impatiente n'est pratique que si votre application utilise une instance de la classe singleton lorsqu'elle démarre. Sinon, vous créerez un objet avant que votre application n'en ait besoin, en utilisant inutilement des ressources.
L'approche paresseuse
L'approche paresseuse est la solution au problème de l'approche avide. Il vous permet de créer une nouvelle instance d'une classe singleton uniquement lorsque votre programme en a besoin.
publicclasseLazySingleton{
privévolatilstatique instance LazySingleton ;privéLazySingleton(){}
publicstatique LazySingleton getInstance(){
si (exemple == nul) {
synchronisé (LazySingleton.classe) {
si (exemple == nul) {
exemple = nouveau LazySingleton();
}
}
}
retour exemple;
}
}
L'approche paresseuse résout le problème du multithreading en utilisant synchronisé mot-clé. Cela empêche deux threads d'accéder à la variable d'instance en même temps. Cependant, la synchronisation est coûteuse, donc l'application ne l'utilise qu'une seule fois, lorsqu'elle appelle getInstance() pour la première fois.
Quand utiliser le modèle Singleton
Le modèle Singleton est utile dans de nombreux scénarios, pour créer des boîtes de dialogue, gérer les paramètres de registre ou gérer les pools de threads.
Une autre utilisation courante du modèle singleton consiste à créer une classe centrale qui gère les connexions à la base de données.
