Implementazione di Singleton con un Enum (in Java)

Ho letto che è possibile implementare Singletonin Java usando Enumcome:

public enum MySingleton {
     INSTANCE;   
}

Ma come funziona quanto sopra? In particolare, Objectè necessario creare un'istanza. Qui, come viene MySingletonistanziata? Chi sta facendo new MySingleton()?

Questo,

public enum MySingleton {
  INSTANCE;   
}

ha un costruttore vuoto implicito. Rendilo esplicito invece,

public enum MySingleton {
    INSTANCE;
    private MySingleton() {
        System.out.println("Here");
    }
}

Se poi hai aggiunto un'altra classe con un main()metodo simile

public static void main(String[] args) {
    System.out.println(MySingleton.INSTANCE);
}

Vedresti

Here
INSTANCE

enumi campi sono costanti di tempo di compilazione, ma sono istanze del loro enumtipo. Inoltre, sono costruiti quando si fa riferimento al tipo enum per la prima volta .

Un enumtipo è un tipo speciale di class.

Il tuo enumsarà effettivamente compilato in qualcosa del genere

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

Al primo accesso al codice INSTANCE, la classe MySingletonverrà caricata e inizializzata da JVM. Questo processo inizializza il staticcampo sopra una volta (pigramente).

In questo libro sulle migliori pratiche Java di Joshua Bloch, puoi scoprire perché dovresti applicare la proprietà Singleton con un costruttore privato o un tipo Enum. Il capitolo è piuttosto lungo, quindi tenendolo in sintesi:

Rendere una classe un Singleton può rendere difficile testare i suoi clienti, poiché è impossibile sostituire un'implementazione simulata con un singleton a meno che non implementi un'interfaccia che funge da tipo. L'approccio consigliato è implementare Singletons semplicemente creando un tipo enum con un elemento:

// Enum singleton - the preferred approach
public enum Elvis {
INSTANCE;
public void leaveTheBuilding() { ... }
}

Questo approccio è funzionalmente equivalente all'approccio di campo pubblico, tranne per il fatto che è più conciso, fornisce gratuitamente i macchinari di serializzazione e fornisce una garanzia coraggiosa contro l'istanza multipla, anche di fronte a sofisticati attacchi di serializzazione o di riflessione.

Mentre questo approccio deve ancora essere ampiamente adottato, un tipo enum a elemento singolo è il modo migliore per implementare un singleton.

Come tutte le istanze enum, Java crea un'istanza per ogni oggetto quando la classe viene caricata, con una certa garanzia che viene istanziata esattamente una volta per JVM . Pensa alla INSTANCEdichiarazione come a un campo finale statico pubblico: Java creerà un'istanza dell'oggetto la prima volta che si fa riferimento alla classe.

Le istanze vengono create durante l'inizializzazione statica, definita nella specifica del linguaggio Java, sezione 12.4 .

Per quello che vale, Joshua Bloch descrive questo modello in dettaglio come elemento 3 di Effective Java Second Edition .

Dato che Singleton Pattern riguarda avere un costruttore privato e chiamare un metodo per controllare le istanze (come alcuni getInstance), in Enums abbiamo già un costruttore privato implicito.

Non so esattamente come la JVM o alcuni container controllino le istanze della nostra Enums, ma sembra che usi già un implicito Singleton Pattern, la differenza è che non chiamiamo a getInstance, chiamiamo semplicemente Enum.

Come è stato precedentemente menzionato, un enum è una classe java con la condizione speciale che la sua definizione debba iniziare con almeno una "costante enum".

A parte questo, e che gli enum non possono essere estesi o usati per estendere altre classi, un enum è una classe come qualsiasi classe e la si usa aggiungendo metodi sotto le definizioni costanti:

public enum MySingleton {
    INSTANCE;

    public void doSomething() { ... }

    public synchronized String getSomething() { return something; }

    private String something;
}

Accedete ai metodi del singleton seguendo queste linee:

MySingleton.INSTANCE.doSomething();
String something = MySingleton.INSTANCE.getSomething();

L'uso di un enum, invece di una classe, è, come è stato detto in altre risposte, principalmente su un'istanza thread-safe del singleton e una garanzia che sarà sempre solo una copia.

E, forse, soprattutto, che questo comportamento è garantito dalla stessa JVM e dalle specifiche Java.

Ecco una sezione dalla specifica Java su come vengono impedite più istanze di un'istanza enum:

Un tipo enum non ha istanze diverse da quelle definite dalle sue costanti enum. È un errore in fase di compilazione tentare di creare un'istanza esplicita di un tipo enum. Il metodo di clonazione finale in Enum assicura che le costanti di enum non possano mai essere clonate, e il trattamento speciale con il meccanismo di serializzazione garantisce che istanze duplicate non vengano mai create come risultato della deserializzazione. È vietata l'istanza riflessiva dei tipi di enum. Insieme, queste quattro cose assicurano che non esistano istanze di un tipo enum oltre a quelle definite dalle costanti enum.

Vale la pena notare che dopo l'istanza tutte le preoccupazioni relative alla sicurezza dei thread devono essere gestite come in qualsiasi altra classe con la parola chiave sincronizzata ecc.