Introduzione: Il modello Singleton in applicazioni di ingegneria multi-treccia

Il modello Singleton è uno dei modelli di progettazione creatina più utilizzati nell'ingegneria del software. Assicura che una classe abbia un solo caso e fornisce un punto di accesso globale a tale istanza. Nelle applicazioni a testo singolo, l'implementazione di un singoloton è semplice: rendere il costruttore privato, fornire un metodo statico che restituisce una singola istanza creata con entusiasmo o pigrizia.

Questo articolo esamina gli sviluppatori di errori più comuni che fanno quando si implementa il modello Singleton in ambienti multi-threaded, spiega le cause sottostanti, e fornisce un insieme completo di migliori pratiche e modelli per evitarli. Include anche esempi di codice pratico in Java, con riferimenti a modelli equivalenti in C++ e C#, e raccomanda risorse esterne per ulteriori letture.

Errori comuni nell'attuazione di Singleton

Anche gli sviluppatori esperti possono cadere in trappole quando si implementano singleton in sistemi concomitanti. Di seguito sono gli errori più frequenti, ciascuno con una spiegazione del perché sono pericolosi.

1. Non rendere il costruttore privato

Se il costruttore è accessibile (pubblico, protetto o privato), qualsiasi thread può creare una nuova istanza, rompendo il contratto singleton. In codice multi-thread, questo può accadere inavvertitamente quando una classe viene rifatto e la visibilità del costruttore è accidentalmente cambiata, o quando la classe è sottoclasse, dichiarando che il singolo è un singolo strumento di protezione.

2. Non gestire la sicurezza del filo

In un ambiente mono-tetto, un semplice inizializzazione pigro funziona bene:

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

Ma in un'applicazione multi-threaded, due o più filetti possono inserire contemporaneamente il controllo prima che qualsiasi thread abbia creato l'istanza. Ogni thread poi procede a creare il proprio oggetto, violando il modello. Questo è un classico condizione di gara]]] che si traduce in più istanze e può portare a perdite di stato o di risorse inconsistenti.

3. Utilizzo di inizializzazione pigra senza la corretta sincronizzazione

Anche gli sviluppatori che riconoscono la necessità di sicurezza del thread spesso aggiungono la sincronizzazione ingenua. Ad esempio, sincronizzando l'intero metodo [] funziona ma introduce un collo di bottiglia di prestazioni:

public static synchronized Singleton getInstance() { ... }

Ogni chiamata a acquisisce e rilascia la serratura, anche dopo che l'istanza è già stata creata. In scenari ad alto contenuto, questa testata può degradare gravemente la produttività. L'approccio migliore è quello di utilizzare doppio controllo blocco[] (discusso sotto), ma anche che il modello ha insidie se non implementato correttamente.

4. Sovrapposizione della sincronizzazione

La sincronizzazione è in molte forme: metodi, blocchi, , [], e così via. Sovrasincronizzazione – applicando le serrature grossolane-grained quando il controllo fine-grained è disponibile – si lancia a una contenzione inutile.

5. Ignorando la volatile[ Parola chiave

In lingue come Java, C# e C++ (con ), la parola chiave [volatile[] (o equivalente) è essenziale per una corretta visibilità nel codice multi-threaded. Senza di essa, il compilatore o la CPU possono riordinare le istruzioni, e le modifiche effettuate da un thread non possono essere visibili ad un altro.

Migliori Pratiche per l'implementazione di Thread-Safe Singleton

Per evitare queste insidie, seguire queste strategie provate. Ogni approccio affronta sicurezza, prestazioni e semplicità del thread.

Costruzionista e Tribunale di primo grado

Indipendentemente dalla strategia di inizializzazione, il costruttore deve essere privato. L'istanza singleton dovrebbe essere memorizzata in un campo statico. Non esporre il costruttore in alcun modo, e considerare di fare la classe in Java (o in C#) per prevenire la sottoclassificazione.

Utilizzare blocchi sincronizzati solo quando necessario

Per la pigrizia inizializzazione, il modello di chiusura a doppio controllo riduce la sincronizzazione in testa:

public class Singleton {
 private static volatile Singleton instance;

 private Singleton() {}

 public static Singleton getInstance() {
 Singleton result = instance; // Local variable for performance
 if (result == null) {
 synchronized (Singleton.class) {
 result = instance;
 if (result == null) {
 instance = result = new Singleton();
 }
 }
 }
 return result;
 }
}

In questo codice, il controllo ] al di fuori del blocco sincronizzato evita il blocco in testa quando l'istanza già esiste. Il controllo interno assicura che solo un thread crea l'istanza. La parola chiave impedisce l'istruzione riordinare e assicura che l'assegnazione è completamente visibile ad altri thread.

Inizializzazione desiderosa

Se il singolo è sempre necessario e la creazione è economica, l'inizializzazione impaziente è l'approccio più semplice per la sicurezza del thread:

public class Singleton {
 private static final Singleton INSTANCE = new Singleton();

 private Singleton() {}

 public static Singleton getInstance() {
 return INSTANCE;
 }
}

Il caricamento delle classi è intrinsecamente sincronizzato dal JVM, quindi non è necessario un coordinamento aggiuntivo, ma questo crea l'istanza in tempo di carico di classe, che può essere indesiderabile in sistemi contrattati dalle risorse o quando il singoloton dipende dalla configurazione di runtime che non è ancora disponibile.

Modello del supporto statico (Inizializzazione-on-demand)

Questo modello combina la pigrizia inizializzazione con la sicurezza del thread senza sincronizzazione esplicita:

public class Singleton {
 private Singleton() {}

 private static class Holder {
 static final Singleton INSTANCE = new Singleton();
 }

 public static Singleton getInstance() {
 return Holder.INSTANCE;
 }
}

La classe viene caricata solo quando [] viene chiamata per la prima volta, e il JVM garantisce una pubblicazione sicura del campo statico durante il caricamento di classe.

Sintonizzato a base di Enum (Java)

Joshua Bloch’s Effective Java[] raccomanda di usare un enum:

public enum Singleton {
 INSTANCE;

 // methods and fields
}

Le costanti di Enum sono implicitamente , e la lingua Java garantisce che le istanze di enum siano create solo una volta, anche in attacchi di serializzazione o riflessione. Ciò è sia sicuro che conciso. Tuttavia, enums non può estendere le classi (solo implementare interfacce), quindi non sono adatti a tutti i casi di utilizzo.

Modelli equivalenti in C++ e C#

In C++, il Singolo del Meyer[ (inizializzazione statica locale) è sicuro dal C++11:

Singleton& getInstance() {
 static Singleton instance;
 return instance;
}

In C#, la classe fornisce un'inizializzazione lazy integrata per thread:

public class Singleton {
 private static readonly Lazy<Singleton> _lazy =
 new Lazy<Singleton>(() => new Singleton());

 public static Singleton Instance => _lazy.Value;
}

Test e considerazioni in applicazioni ingegneristiche

Nelle applicazioni di ingegneria, il modello singleton spesso gestisce risorse condivise come driver hardware, impostazioni di configurazione, pool di filettati o servizi di registrazione.

  • Fare i singolitoni testabili[[]] fornendo un modo per ripristinare l'istanza (ad esempio, un metodo protetto [] utilizzato solo nelle prove) o iniettando dipendenze tramite un'interfaccia. Molte applicazioni moderne evitano singletons completamente a favore di framework di iniezione di dipendenza che gestiscono il ciclo di vita.
  • Profilo di conformità[[]] in tempo reale o ad alta frequenza: misurare la sovraccarico della sincronizzazione. In alcuni casi, un singolotone senza serratura utilizzando (C#) o (C++) può essere giustificato.
  • I sistemi distribuiti[[] richiedono che i singolitoni siano unici per processo, non attraverso i processi. Se avete bisogno di un singoloton a livello di cluster, usate il coordinamento esterno (ad esempio, un database, ZooKeper o elezioni leader).
  • La riflessione e la serializzazione[[]] possono rompere i singoli. Utilizzare [ nella serializzazione Java, e prevenire l'istantanea riflettente gettando un'eccezione nel costruttore se è già impostato.

Conclusioni

Il modello Singleton rimane uno strumento prezioso nella cassetta degli strumenti dell'ingegnere software, ma la sua implementazione in ambienti multi-threaded richiede una rigorosa attenzione ai dettagli. La comprensione ed evitare errori comuni, come i costruttori non privati, la sincronizzazione mancante, l'uso improprio e volatile, e la sovra-sincronizzazione-based, i sviluppatori possono produrre singoli robusti e ad alte prestazioni.

Per ulteriori studi, consultare le seguenti risorse:

In definitiva, la migliore implementazione singleton è quella più semplice per le vostre esigenze. Quando in dubbio, preferiscono l'inizializzazione ansiosa o il modello di supporto statico, e sempre scrivere test di unità concomitanti per convalidare la correttezza sotto la contention.