Het singleton-patroon is een van de eenvoudigere ontwerppatronen. Een klasse die het singleton-ontwerppatroon gebruikt, heeft een enkele instantie die deze zelfstandig beheert. Deze klasse voorkomt dat een andere klasse er een instantie van maakt.
Een singleton-klasse biedt ook één globaal toegangspunt tot de instantie die wordt gemaakt. Dus elke klasse die een instantie van een singleton-klasse wil, moet er toegang toe krijgen via zijn enkele toegangspunt.
Java's uitstekende ondersteuning voor objectgeoriënteerd programmeren maakt het gemakkelijk om het singleton-ontwerppatroon te gebruiken.
Het Singleton-patroon implementeren met behulp van Java
Er zijn veel manieren om het singleton-patroon in Java te implementeren; de enthousiaste en luie benaderingen zijn veelvoorkomende variaties. Elk van deze benaderingen heeft zijn eigen voor- en nadelen. Daarom moet de methode die u kiest, afhangen van hoe uw toepassing zal werken.
De Eager-benadering
Het implementeren van het singleton-patroon met de gretige benadering betekent dat de klasse een nieuwe instantie van zichzelf maakt wanneer deze wordt geladen.
openbaarklasEagerSingleton{
privaatstatisch EagerSingleton-instantie = nieuw EagerSingleton();privaatEagerSingleton(){}
openbaarstatisch EagerSingleton getInstance(){
opbrengst voorbeeld;
}
}
De EagerSingletonJava-klasse maakt een nieuwe instantie van zichzelf tijdens het laden. Het wijst deze instantie toe aan de private static instantievariabele, die alleen toegankelijk is binnen de singleton-klasse. Het enige punt van externe toegang tot de instantievariabele is via de getInstance() methode. Die methode retourneert de eerder gemaakte instantie van de klasse.
Deze aanpak is geweldig omdat het de multithreading probleem, wat een van de grootste uitdagingen is van het singleton-patroon. Het lost het multithreading-probleem op door een nieuwe instantie van zichzelf te maken voordat een nieuwe thread toegang heeft tot de instantievariabele. Dit garandeert dat elke thread alleen toegang heeft tot dezelfde instantie.
De gretige benadering is echter alleen praktisch als uw toepassing een instantie van de singleton-klasse gebruikt wanneer deze wordt gestart. Anders maakt u een object voordat uw toepassing het nodig heeft, waardoor u onnodig bronnen gebruikt.
De luie aanpak
De luie benadering is de oplossing voor het probleem van de enthousiaste benadering. Hiermee kunt u alleen een nieuwe instantie van een singleton-klasse maken wanneer uw programma dit nodig heeft.
openbaarklasLazySingleton{
privaatvluchtigstatisch LazySingleton-instantie;privaatLazySingleton(){}
openbaarstatisch LazySingleton getInstance(){
als (voorbeeld == nul) {
gesynchroniseerd (Luie Singleton.klas) {
als (voorbeeld == nul) {
instantie = nieuw LazySingleton();
}
}
}
opbrengst voorbeeld;
}
}
De luie benadering lost het multithreading-probleem op met behulp van de gesynchroniseerd trefwoord. Dit voorkomt dat twee threads tegelijkertijd toegang krijgen tot de instantievariabele. Gesynchroniseerd is echter duur, dus de applicatie gebruikt het maar één keer, wanneer het voor het eerst getInstance() aanroept.
Wanneer gebruik je het Singleton-patroon?
Het Singleton-patroon is in veel scenario's nuttig om dialoogvensters te maken, registerinstellingen af te handelen of threadpools te beheren.
Een ander veelgebruikt gebruik van het singleton-patroon is het maken van een centrale klasse die databaseverbindingen beheert.