Singleton-mönstret är ett av de enklare designmönstren. En klass som använder singleton-designmönstret har en enda instans som den hanterar på egen hand. Den här klassen förhindrar någon annan klass från att skapa en instans av den.
En singleton-klass tillhandahåller också en enda global åtkomstpunkt till instansen som den skapar. Så, alla klasser som vill ha en instans av en singleton-klass, måste komma åt den via sin enda åtkomstpunkt.
Javas utmärkta stöd för objektorienterad programmering gör det enkelt att använda singeldesignmönstret.
Implementering av Singleton-mönstret med Java
Det finns många sätt att implementera singleton-mönstret i Java; de ivriga och lata tillvägagångssätten är vanliga varianter. Var och en av dessa tillvägagångssätt har sina egna fördelar och nackdelar. Därför bör metoden du väljer att använda bero på hur din applikation kommer att fungera.
Det ivriga tillvägagångssättet
Att implementera singelmönstret med det ivriga tillvägagångssättet innebär att klassen skapar en ny instans av sig själv när den laddas.
offentligklassEagerSingleton{
privatstatisk EagerSingleton-instans = ny EagerSingleton();privatEagerSingleton(){}
offentligstatisk EagerSingleton getInstance(){
lämna tillbaka exempel;
}
}
De EagerSingletonJava klass skapar en ny instans av sig själv när den laddas. Den tilldelar denna instans till den privata statiken instansvariabel, som endast är tillgänglig inom singleton-klassen. Den enda punkten för extern åtkomst till instansvariabeln är genom getInstance() metod. Den metoden returnerar den tidigare skapade instansen av klassen.
Detta tillvägagångssätt är bra eftersom det förhindrar multitrådning problem, vilket är en av de största utmaningarna med singelmönstret. Det löser multithreading-problemet genom att skapa en ny instans av sig själv innan någon ny tråd kan komma åt sin instansvariabel. Detta garanterar att varje tråd bara kommer att ha tillgång till samma instans.
Men det ivriga tillvägagångssättet är bara praktiskt om din applikation kommer att använda en instans av singleton-klassen när den börjar köras. Annars skapar du ett objekt innan ditt program behöver det, och använder resurser i onödan.
Det lata tillvägagångssättet
Det lata tillvägagångssättet är lösningen på problemet med ivriga tillvägagångssätt. Det låter dig skapa en ny instans av en singleton-klass endast när ditt program behöver det.
offentligklassLazySingleton{
privatflyktigstatisk LazySingleton-instans;privatLazySingleton(){}
offentligstatisk LazySingleton getInstance(){
om (instans == null) {
synkroniserad (LazySingleton.klass) {
om (instans == null) {
instans = ny LazySingleton();
}
}
}
lämna tillbaka exempel;
}
}
Det lata tillvägagångssättet löser multithreading-problemet med hjälp av synkroniserad nyckelord. Detta förhindrar att två trådar får åtkomst till instansvariabeln samtidigt. Synkroniserat är dock dyrt, så programmet använder det bara en gång, när det först anropar getInstance().
När ska man använda Singleton-mönstret
Singleton-mönstret är användbart i många scenarier, för att skapa dialogrutor, hantera registerinställningar eller hantera trådpooler.
En annan vanlig användning för singelmönstret är att skapa en central klass som hanterar databasanslutningar.
