Singleton Pattern är förmodligen det mest använda designmönstret. Det är ett enkelt mönster, lätt att förstå och att använda. Ibland används det i överskott och i scenarier där det inte krävs. I sådana fall överväger nackdelarna med att använda det fördelarna det medför. Av denna anledning anses singelmönster ibland vara ett antimönster eller mönster singleton .

mysql inte lika

Viktiga ämnen för Singleton Method Design Pattern

• Vad är Singleton Method Design Pattern?
• När ska man använda Singleton Method Design Pattern?
• Initialiseringstyper av Singleton
• Nyckelkomponent i Singleton-metodens designmönster:
• Implementering av Singleton Method Design Pattern
• Olika sätt att implementera Singleton Method Design Pattern
• Använd Case of Pattern Singleton Method
• Fördelar med Singleton Method Design Pattern:
• Nackdelar med Singleton Design Pattern

1. Vad är Singleton Method Design Pattern?

Singleton-metoden eller Singleton Design-mönster är ett av de enklaste designmönstren. Det säkerställer att en klass bara har en instans och ger en global åtkomstpunkt till den.

2. När ska man använda Singleton Method Design Pattern?

Använd Singleton-metoden Design Pattern när:

• Det måste finnas exakt en instans av en klass och den måste vara tillgänglig för klienter från en välkänd åtkomstpunkt.
• När den enda instansen ska kunna utökas genom underklassning och klienter ska kunna använda en utökad instans utan att ändra
• Singleton-klasser används för loggning, drivrutinsobjekt, cachelagring och trådpool, databasanslutningar.

3. Initialiseringstyper av Singleton

Singleton-klassen kan instansieras med två metoder:

• Tidig initiering: I denna metod initieras klass oavsett om den ska användas eller inte. Den största fördelen med denna metod är dess enkelhet. Du startar klassen när klassen laddas. Dess nackdel är att klass alltid initieras oavsett om den används eller inte.
• Lat initialisering: I den här metoden initieras klass endast när det krävs. Det kan rädda dig från att instansiera klassen när du inte behöver den. I allmänhet används lat initialisering när vi skapar en singleton-klass.

4. Nyckelkomponent i Singleton-metodens designmönster:

arrayer i java

4.1. Statisk medlem:

Singleton-mönstret eller mönstret Singleton använder en statisk medlem inom klassen. Denna statiska medlem säkerställer att minnet tilldelas endast en gång, vilket bevarar den enda instansen av Singleton-klassen.

// Static member to hold the single instance private static Singleton instance;>

4.2. Privat konstruktör:

Singleton-mönstret eller mönstret singleton innehåller en privat konstruktör, som fungerar som en barrikad mot externa försök att skapa instanser av Singleton-klassen. Detta säkerställer att klassen har kontroll över sin instansieringsprocess.

// Private constructor to // prevent external instantiation class Singleton {  // Making the constructor as Private  private Singleton()  {  // Initialization code here  } }>

4.3. Statisk fabriksmetod:

En avgörande aspekt av Singleton-mönstret är närvaron av en statisk fabriksmetod. Denna metod fungerar som en gateway och ger en global åtkomstpunkt till Singleton-objektet. När någon begär en instans skapar den här metoden antingen en ny instans (om ingen finns) eller returnerar den befintliga instansen till den som ringer.

// Static factory method for global access public static Singleton getInstance() {  // Check if an instance exists  if (instance == null) {  // If no instance exists, create one  instance = new Singleton();  }  // Return the existing instance  return instance; }>

5. Implementering av Singleton Method Design Pattern

Implementeringen av ett Singleton Design Pattern eller Pattern Singleton beskrivs i följande klassdiagram:

Implementering av Singleton Method Design Pattern

Implementeringen av singleton Design-mönstret är mycket enkel och består av en enda klass. För att säkerställa att singleton-instansen är unik bör alla singleton-konstruktörer göras privata. Global åtkomst görs genom en statisk metod som kan nås globalt till en enda instans enligt koden.

/*package whatever //do not write package name here */ import java.io.*; class Singleton {  // static class  private static Singleton instance;  private Singleton()  {  System.out.println('Singleton is Instantiated.');  }  public static Singleton getInstance()  {  if (instance == null)  instance = new Singleton();  return instance;  }  public static void doSomething()  {  System.out.println('Somethong is Done.');  } } class GFG {  public static void main(String[] args)  {  Singleton.getInstance().doSomething();  } }>

Singleton is Instantiated. Somethong is Done.>

Metoden getInstance, vi kontrollerar om instansen är null. Om instansen inte är null betyder det att objektet skapades tidigare; annars skapar vi den med den nya operatorn.

6. Olika sätt att implementera Singleton Method Design Pattern

Ibland behöver vi bara ha en instans av vår klass, till exempel en enda DB-anslutning som delas av flera objekt eftersom det kan vara kostsamt att skapa en separat DB-anslutning för varje objekt. På samma sätt kan det finnas en enda konfigurationshanterare eller felhanterare i en applikation som hanterar alla problem istället för att skapa flera hanterare.

latex bord

Låt oss se olika designalternativ för att implementera en sådan klass. Om du har bra koll på statiska klassvariabler och åtkomstmodifierare borde detta inte vara en svår uppgift.

Metod 1 – Klassisk implementering || Gör getInstance() statisk för att implementera Singleton metod designmönster

// Classical Java implementation of singleton // design pattern class Singleton {  private static Singleton obj;  // private constructor to force use of  // getInstance() to create Singleton object  private Singleton() {}  public static Singleton getInstance()  {  if (obj == null)  obj = new Singleton();  return obj;  } }>

Här har vi deklarerat getInstance() statisk så att vi kan kalla det utan att instansiera klassen. Första gången getInstance() kallas det skapar ett nytt singleton-objekt och efter det returnerar det bara samma objekt.

Notera: Singleton obj skapas inte förrän vi behöver den och kallar den getInstance() metod. Detta kallas lat instansiering. Det största problemet med metoden ovan är att den inte är trådsäker. Tänk på följande exekveringssekvens.

java list nod

Denna exekveringssekvens skapar två objekt för singeln. Därför är denna klassiska implementering inte trådsäker.

Metod 2 || Gör getInstance() synkroniserad för att implementera Singleton metod designmönster

// Thread Synchronized Java implementation of // singleton design pattern class Singleton {  private static Singleton obj;  private Singleton() {}  // Only one thread can execute this at a time  public static synchronized Singleton getInstance()  {  if (obj == null)  obj = new Singleton();  return obj;  } }>

Här säkerställer användning av synkroniserat att endast en tråd åt gången kan köras getInstance() . Den största nackdelen med den här metoden är att det är dyrt att använda synkroniserad varje gång när du skapar singleton-objektet och kan minska prestandan för ditt program. Men om utförandet av getInstance() är inte avgörande för din applikation, denna metod ger en ren och enkel lösning.

Metod 3 – Ivrig instansiering || Statisk initialiseringsbaserad implementering av singleton designmönster

// Static initializer based Java implementation of // singleton design pattern class Singleton {  private static Singleton obj = new Singleton();  private Singleton() {}  public static Singleton getInstance() { return obj; } }>

Här har vi skapat en instans av en singleton i en statisk initialiserare. JVM kör en statisk initialiserare när klassen laddas och därför är detta garanterat trådsäkert. Använd den här metoden endast när din singleton-klass är lätt och används under hela programmets körning.

Metod 4 – Mest effektiv || Använd Double Checked Locking för att implementera singleton designmönster

Om du märker noggrant när ett objekt har skapats är synkronisering inte längre användbar eftersom obj nu inte kommer att vara null och varje sekvens av operationer kommer att leda till konsekventa resultat. Så vi skaffar bara låset på getInstance() en gång när obj är null. På så sätt synkroniserar vi bara den första vägen igenom, precis vad vi vill.

// Double Checked Locking based Java implementation of // singleton design pattern class Singleton {  private static volatile Singleton obj = null;  private Singleton() {}  public static Singleton getInstance()  {  if (obj == null) {  // To make thread safe  synchronized (Singleton.class)  {  // check again as multiple threads  // can reach above step  if (obj == null)  obj = new Singleton();  }  }  return obj;  } }>

Vi har deklarerat obj flyktig vilket säkerställer att flera trådar erbjuder obj-variabeln korrekt när den initieras till Singleton-instansen. Denna metod minskar drastiskt kostnaderna för att anropa den synkroniserade metoden varje gång.

7. Använd Case of Pattern Singleton Method

• Databasanslutningar: I applikationer där att skapa och hantera databasanslutningar är en dyr operation, kan en Singleton användas för att upprätthålla en enda databasanslutning genom hela applikationen.
• Konfigurationshantering: När du har globala konfigurationsinställningar som behöver nås av olika komponenter i applikationen, kan en Singleton-konfigurationshanterare tillhandahålla en enda åtkomstpunkt till dessa inställningar.
• GUI-komponenter: För komponenter eller styrenheter för grafiskt användargränssnitt (GUI) kan en Singleton hjälpa till att hantera gränssnittets tillstånd och åtgärder, vilket ger en enda kontrollpunkt.
• Enhetshanterare: I inbyggda system eller applikationer som interagerar med hårdvaruenheter kan en Singleton användas för att hantera och kontrollera åtkomst till hårdvaruenheter för att undvika konflikter.
• Utskriftstjänst: I system som involverar utskrift av dokument eller rapporter kan en Singleton-utskriftstjänst koordinera och hantera utskriftsjobb, vilket säkerställer effektiv användning av utskriftsresurser.

8. Fördelar med Singleton Method Design Pattern:

• Löser namnkollisioner: I scenarier där en enda kontrollpunkt behövs för att undvika namnkonflikter eller kollisioner, säkerställer Singleton-mönstret att det bara finns en instans med ett unikt namn.
• Ivrig eller lat initialisering: Singleton-mönstret stöder både ivrig initiering (skapa instansen när klassen laddas) och lat initiering (skapa instansen när den först efterfrågas), vilket ger flexibilitet baserat på användningsfallet.
• Trådsäkerhet: Korrekt implementerade Singleton-mönster kan ge trådsäkerhet, vilket säkerställer att instansen skapas atomärt och att flera trådar inte oavsiktligt skapar dubbletter av instanser.
• Minskat minnesavtryck: I applikationer där resursförbrukningen är kritisk kan Singleton-mönstret bidra till ett minskat minnesavtryck genom att säkerställa att det bara finns en instans av klassen.

9. Nackdelar med Singleton Design Pattern

• Testsvårigheter: Eftersom Singletons introducerar global state, kan enhetstester bli utmanande. Att testa en komponent isolerat kan vara mer komplicerat om den förlitar sig på en Singleton, eftersom Singletonens tillstånd kan påverka resultatet av tester.
• Samtidighetsproblem: I en flertrådig miljö kan det finnas problem relaterade till skapandet och initieringen av Singleton-instansen. Om flera trådar försöker skapa Singleton samtidigt kan det resultera i tävlingsförhållanden.
• Begränsad töjbarhet: Singleton-mönstret kan göra koden mindre töjbar. Om du senare bestämmer dig för att du behöver flera instanser av klassen eller vill ändra instansieringslogiken, kan det kräva betydande refaktorisering.
• Globalt beroende: Singleton-mönstret skapar ett globalt beroende, vilket gör det svårare att ersätta Singleton med en alternativ implementering eller att använda beroendeinjektion för att tillhandahålla instanser.
• Svårt att underklassa: Att underklassa en Singleton kan vara utmanande. Eftersom konstruktören vanligtvis är privat, kräver förlängning av en Singleton ytterligare vård och följer kanske inte vanliga arvsmönster.
• Livscykelhantering: Singleton-mönstret kanske inte hanterar scenarier där instansen uttryckligen behöver förstöras eller återställas. Att hantera Singletons livscykel kan bli ett problem.
• Missbruk av global åtkomstpunkt: Även om en global åtkomstpunkt är en fördel kan den också missbrukas. Utvecklare kan frestas att använda Singleton till allt, vilket leder till en överanvändning av globala tillstånd och en mindre modulär design.

10. Slutsats

Det är viktigt för vissa klasser att ha exakt en instans. Även om det kan finnas många skrivare i ett system, bör det bara finnas en skrivarspooler. Det ska bara finnas ett filsystem och en fönsterhanterare. Ett digitalt filter kommer att ha en A/D-omvandlare. Ett redovisningssystem kommer att ägnas åt att betjäna ett företag. Hur säkerställer vi att en klass bara har en instans och att instansen är lättillgänglig? En global variabel gör ett objekt tillgängligt, men det hindrar dig inte från att instansiera flera objekt.

En bättre lösning är att göra klassen själv ansvarig för att hålla reda på sin enda instans. Klassen kan säkerställa att ingen annan instans kan skapas (genom att fånga upp förfrågningar om att skapa nya objekt), och den kan ge ett sätt att komma åt instansen. Detta är Singleton-mönstret.