Was ist eine effiziente Methode zum implementieren eines singleton-pattern in Java?

Verwendung einer enum:

public enum Foo {
    INSTANCE;
}

Joshua Bloch erläutert dieses Konzept in seinem Effektive Java-Reloaded Vortrag auf der Google I/O 2008: link zum video. Siehe auch Folien 30-32 seiner Präsentation (effective_java_reloaded.pdf):

Das Recht, die Implementierung der Serializable-Singleton -

public enum Elvis {
    INSTANCE;
    private final String[] favoriteSongs =
        { "Hound Dog", "Heartbreak Hotel" };
    public void printFavorites() {
        System.out.println(Arrays.toString(favoriteSongs));
    }
}

Edit: Eine online-Angebot von "Effective Java" sagt:

"Dieser Ansatz ist funktional äquivalent zu den öffentlichen Feld-Ansatz, außer dass es ist übersichtlicher, bietet die Serialisierung Maschinen kostenlos, und bietet ein "ironclad" - Garantie gegen multiple Instanziierung, auch im Angesicht der anspruchsvolle Serialisierung oder reflection-Angriffen. Während dieser Ansatz noch nicht weit verbreitet, ein single-element enum-Typ ist der beste Weg zur Implementierung eines singleton."

InformationsquelleAutor Stephen Denne

Haftungsausschluss: ich habe nur zusammengefasst alle genial Antworten und schrieb es in meinen Worten.

Während der Implementierung des Singleton-wir haben 2 Optionen

1. Lazy loading

2. Frühzeitige Belastung

Lazy loading Hinzugefügt bit-overhead(viel, um ehrlich zu sein) so verwenden Sie es nur, wenn Sie ein sehr großes Objekt oder schwere Konstruktion-code UND auch andere zugängliche statische Methoden oder Felder, die verwendet werden könnten, bevor eine Instanz benötigt wird, dann und nur dann müssen Sie die Verwendung von lazy-Initialisierung.Ansonsten ist die Wahl eine frühzeitige Belastung ist eine gute Wahl.

Meisten einfache Weise der Implementierung der Singleton ist

public class Foo {

    //It will be our sole hero
    private static final Foo INSTANCE = new Foo();

    private Foo() {
        if (INSTANCE != null) {
            //SHOUT
            throw new IllegalStateException("Already instantiated");
        }
    }

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

Alles ist gut, außer seinem frühen geladen singleton. Sie können versuchen lazy geladen singleton

class Foo {

    //Our now_null_but_going_to_be sole hero 
    private static Foo INSTANCE = null;

    private Foo() {
        if (INSTANCE != null) {
            //SHOUT  
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static Foo getInstance() {
        //Creating only  when required.
        if (INSTANCE == null) {
            INSTANCE = new Foo();
        }
        return INSTANCE;
    }
}

So weit So gut, aber unser held wird nicht überleben, während die Bekämpfung von allein mit mehreren bösen threads, die wollen viele, viele Beispiel unseres Helden.
So können schützen Sie vor bösen multi-threading

class Foo {

    private static Foo INSTANCE = null;

    //TODO Add private shouting constructor

    public static Foo getInstance() {
        //No more tension of threads
        synchronized (Foo.class) {
            if (INSTANCE == null) {
                INSTANCE = new Foo();
            }
        }
        return INSTANCE;
    }
}

aber es ist nicht genug, um aus Helden, Wirklich!!!!!! Dies ist das beste, was wir können/sollten tun, um zu helfen, unser held,

class Foo {

    //Pay attention to volatile
    private static volatile Foo INSTANCE = null;

    //TODO Add private shouting constructor

    public static Foo getInstance() {
        if (INSTANCE == null) { //Check 1
            synchronized (Foo.class) {
                if (INSTANCE == null) { //Check 2
                    INSTANCE = new Foo();
                }
            }
        }
        return INSTANCE;
    }
}

Dies wird als "Double-Checked Locking idiom". Es ist leicht zu vergessen, die flüchtige Anweisung und schwer zu verstehen, warum es notwendig ist.

Details : http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

Nun sind wir sicher böse thread, aber was ist mit dem grausamen-Serialisierung? Wir müssen sicherstellen, dass auch während der de-serialiaztion kein neues Objekt erstellt wird,

class Foo implements Serializable {

    private static final long serialVersionUID = 1L;

    private static volatile Foo INSTANCE = null;

    //Rest of the things are same as above

    //No more fear of serialization
    @SuppressWarnings("unused")
    private Object readResolve() {
        return INSTANCE;
    }
}

Die Methode readResolve() wird sicherstellen, dass die einzige Instanz, die zurückgegeben werden, selbst wenn das Objekt serialisiert wurde in einer früheren Ausführung in unserem Programm.

Schließlich haben wir Hinzugefügt genug Schutz gegen Fäden und Serialisierung aber unser code ist auf der Suche sperrig und hässlich. Geben wir unserem Helden einen über

public final class Foo implements Serializable {

    private static final long serialVersionUID = 1L;

    //Wrapped in a inner static class so that loaded only when required
    private static class FooLoader {

        //And no more fear of threads
        private static final Foo INSTANCE = new Foo();
    }

    //TODO add private shouting construcor

    public static Foo getInstance() {
        return FooLoader.INSTANCE;
    }

    //Damn you serialization
    @SuppressWarnings("unused")
    private Foo readResolve() {
        return FooLoader.INSTANCE;
    }
}

Ja, das ist unser sehr gleichen Helden 🙂

Da die Linie private static final Foo INSTANCE = new Foo(); wird nur ausgeführt, wenn die Klasse FooLoader tatsächlich verwendet wird, dieser kümmert sich um die verzögerte Instanziierung,

ist und Sie garantiert werden, um thread-safe.

Und wir kamen so weit, hier ist der beste Weg, um zu erreichen alles, was wir haben ist die beste Möglichkeit

 public enum Foo {
       INSTANCE;
   }

Welche intern behandelt werden wie

public class Foo {

    //It will be our sole hero
    private static final Foo INSTANCE = new Foo();
}

Dass es keine Angst mehr vor der Serialisierung von threads und hässlichen code. Auch ENUMS singleton sind faul initialisiert.

Dieser Ansatz ist funktional äquivalent zu den öffentlichen Feld-Ansatz,
außer, es ist übersichtlicher, bietet die Serialisierung von Maschinen
kostenlos, und bietet ein "ironclad" - Garantie gegen mehrere
Instanziierung, auch im Angesicht der anspruchsvolle Serialisierung bzw.
reflection attacks. Während dieser Ansatz noch nicht weit verbreitet sind,
ein single-element enum-Typ ist der beste Weg zur Implementierung eines singleton.

-Joshua Bloch in "Effective Java"

Nun werden Sie vielleicht erkannt haben, warum ENUMS als besten Weg für die Implementierung von Singleton und danke für Eure Geduld 🙂

Aktualisiert es auf meinem blog.

InformationsquelleAutor xyz

Threadsicherheit in Java 5+:

class Foo {
    private static volatile Bar bar = null;
    public static Bar getBar() {
        if (bar == null) {
            synchronized(Foo.class) {
                if (bar == null)
                    bar = new Bar(); 
            }
        }
        return bar;
    }
}

BEARBEITEN: achten Sie auf die volatile modifier hier. 🙂 Es ist wichtig, weil ohne Sie, die anderen threads sind nicht garantiert durch das JMM (Java-Memory-Modell) zu sehen, die änderungen an seinen Wert. Die Synchronisation nicht kümmern, dass-es nur serialisiert Zugriff auf diesen code-block.

EDIT 2:
@Bno 's Antwort details der Ansatz empfohlen von Bill Pugh (FindBugs) und ist wohl besser. Bitte Lesen, und Stimme seiner Antwort zu.

InformationsquelleAutor Stu Thompson

Stellen Sie sicher, dass Sie es wirklich brauchen. Google nach "singleton-anti-pattern" zu sehen, einige Argumente gegen Sie. Es gibt nichts grundlegend falsch mit ihm, aber ich nehme an es ist nur ein Mechanismus für die Aufdeckung von einigen globalen Ressource/Daten, so stellen Sie sicher, dass dies der beste Weg. Insbesondere habe ich gefunden, dependency injection mehr nützlich, vor allem, wenn Sie auch mit unit-tests, weil DI können Sie verwenden, verspottet Ressourcen für Testzwecke.

InformationsquelleAutor Neil Burroughs

Wirklich überlegen, warum Sie benötigen, um eine singleton-vor dem schreiben. Es ist eine quasi-religiöse Debatte über die Verwendung von Ihnen, die können Sie ganz einfach stolpern, wenn Sie google singletons in Java.

Ich persönlich versuchen zu vermeiden, singletons, so oft wie möglich, für viele Gründe, wieder die meisten von denen gefunden werden kann, durch googeln singletons. Ich habe das Gefühl, dass ziemlich oft singletons missbraucht werden, weil Sie einfach zu verstehen für jedermann, Sie sind als ein Mechanismus für die erste "Globale" Daten in ein OO-design, und Sie werden verwendet, weil es leicht zu umgehen, Objekt-lifecycle-management (oder wirklich, darüber nachzudenken, wie Sie tun können, Eine von innen B). Blick auf Dinge wie IoC (Inversion of Control) oder Dependency Injection (DI) für einen schönen middleground.

Wenn Sie wirklich brauchen, dann ist wikipedia ein gutes Beispiel für eine korrekte Umsetzung eines Singletons.

InformationsquelleAutor

Ich benutze das Spring-Framework für die Verwaltung meiner singletons. Es spielt nicht die Durchsetzung der "singleton-ness" der Klasse (das können Sie eigentlich nicht jedenfalls, wenn es mehrere class loader beteiligt), sondern bietet eine wirklich einfache Möglichkeit zum erstellen und konfigurieren von verschiedenen Fabriken für die Erstellung von verschiedenen Arten von Objekten.

InformationsquelleAutor Matt

Wikipedia hat einige Beispiele von singletons, auch in Java. Die Java-5 Umsetzung sieht ziemlich vollständig, und ist thread-sicher (double-checked locking angewendet).

InformationsquelleAutor macbirdie

Ich würde sagen Enum singleton

Singleton mit enum in Java ist in der Regel Weise zu deklarieren, enum singleton. Enum singleton enthalten können Instanz-Variablen und Instanz-Methode. Der Einfachheit halber beachten Sie auch, dass, wenn Sie eine Instanz-Methode als die Sie benötigen, um thread-Sicherheit der Methode, wenn überhaupt, es auf den Zustand des Objekts.

Die Nutzung einer enum-ist sehr einfach zu implementieren und hat keine Nachteile in Bezug auf serialisierbare Objekte, die umgangen werden kann, in der anderen Weise.

/**
* Singleton pattern example using Java Enum
*/
public enum Singleton {
        INSTANCE;
        public void execute (String arg) {
                //perform operation here
        }
}

Können Sie darauf zugreifen, indem Singleton.INSTANCE, viel einfacher als das aufrufen getInstance() Methode auf Singleton.

1.12 Serialisierung von Enum-Konstanten

Enum-Konstanten werden serialisiert, anders als normale serializable-oder externalizable-Objekte. Die serialisierte form eines enum-Konstanten besteht nur aus seinem Namen; Feld Werte der Konstanten sind nicht in der form. Serialisieren eines enum-Konstanten, ObjectOutputStream schreibt den zurückgegebenen Wert vom enum-Konstanten - name-Methode. Deserialisieren eines enum-Konstanten, ObjectInputStream lautet der name der Konstante aus dem stream; die deserialisiert konstant ist, man erhält dann durch Aufruf der java.lang.Enum.valueOf - Methode auf, übergeben Sie die Konstante der Enumeration-Typ zusammen mit den empfangenen name der Konstante als Argumente. Wie andere serializable-oder externalizable-Objekte, enum-Konstanten können als Ziele der Rückverweise erscheinen anschließend in der Serialisierung stream.

Den Prozess, durch den enum-Konstanten werden serialisiert, können nicht angepasst werden: jede Klasse spezifische writeObject, readObject, readObjectNoData, writeReplace, und readResolve definierten Methoden von enum-Typen werden ignoriert, bei der Serialisierung und Deserialisierung. Ebenso serialPersistentFields oder serialVersionUID Feld-Deklarationen werden ignoriert--alle enum-Typen haben eine Feste serialVersionUID von 0L. Dokumentieren serialisierbare Felder und Daten für das enum-Typen ist überflüssig, da es keine variation in der Art der gesendeten Daten.

Zitiert von Oracle docs

Ein weiteres problem mit herkömmlichen Singletons sind, dass, sobald Sie implementieren Serializable - Schnittstelle, Sie bleiben nicht länger Singleton, weil readObject() - Methode immer wieder eine neue Instanz wie der Konstruktor in Java. Dies kann vermieden werden, indem readResolve() und verwerfen, neu erstellte Instanz durch den Austausch mit singleton-wie unten

 //readResolve to prevent another instance of Singleton
 private Object readResolve(){
     return INSTANCE;
 }

Diese können sogar noch komplexer, wenn die Singleton-Klasse Status beizubehalten, müssen Sie Sie vorübergehend, aber mit in Enum Singleton, Serialisierung ist garantiert durch die JVM.

Gut Lesen

1. Singleton-Muster
2. Enumerationen, Singletons und Deserialisierung
3. Double-checked-locking und das Singleton-pattern

InformationsquelleAutor NullPoiиteя

There are 4 ways to create a singleton in java.

1- eager initialization singleton

    public class Test{
        private static final Test test = new Test();
        private Test(){}
        public static Test getTest(){
            return test;
        }
    ｝

2- lazy initialization singleton (thread safe)

    public class Test {
         private static volatile Test test;
         private Test(){}
         public static Test getTest() {
            if(test == null) {
                synchronized(Test.class) {
                    if(test == null){test = new Test();
                }
            }
         }

        return test;
    ｝


3- Bill Pugh Singleton with Holder Pattern (Preferably the best one)

    public class Test {

        private Test(){}

        private static class TestHolder{
            private static final Test test = new Test();
        }

        public static Test getInstance(){
            return TestHolder.test;
        }
    }

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

InformationsquelleAutor Dheeraj Sachan

Müssen Sie überprüfen idiom, wenn Sie laden müssen die Instanz-Variablen einer Klasse träge.
Wenn Sie brauchen, um zu laden eine statische variable oder ein singleton-träge, die Sie benötigen, initilization-on-demand-Halter idiom.

Darüber hinaus, wenn der singleton muss seriliazble, alle anderen Felder werden muss, transient und readResolve () - Methode muss implementiert werden, um das singleton-Objekt-Invarianten. Ansonsten, jedes mal, wenn das Objekt deserialisiert wird, wird eine neue Instanz des Objekts erstellt werden. Was readResolve () " ersetzen, die das neue Objekt Lesen von readObject(), die gezwungen ist, das neue Objekt von der garbage Collection freigegeben, da es keine variable, die sich auf ihn.

public static final INSTANCE == ....
private Object readResolve() {
  return INSTANCE; //original singleton instance.
} 

InformationsquelleAutor Onur

Enum singleton

Die einfachste Möglichkeit zum implementieren eines Singleton, der thread-safe ist mit einem Enum

public enum SingletonEnum {
  INSTANCE;
  public void doSomething(){
    System.out.println("This is a singleton");
  }
}

Dieser code funktioniert seit der Einführung von Enum in Java 1.5

Double-checked locking

Wenn Sie wollen, um code zu einer "klassischen" singleton, arbeitet in einer multithreaded-Umgebung (ab Java 1.5), sollten Sie diese benutzen.

public class Singleton {

  private static volatile Singleton instance = null;

  private Singleton() {
  }

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

Dies ist nicht thread-sicher vor 1.5 ist, da die Implementierung von volatile-Schlüsselwort war anders.

Frühen Belastung Singleton (funktioniert auch vor Java 1.5)

Diese Implementierung erzeugt das singleton, wenn die Klasse geladen ist und bietet thread-Sicherheit.

public class Singleton {

  private static final Singleton instance = new Singleton();

  private Singleton() {
  }

  public static Singleton getInstance() {
    return instance;
  }

  public void doSomething(){
    System.out.println("This is a singleton");
  }

}

InformationsquelleAutor Dan Moldovan

Ein anderes argument, das oft gegen Singletons sind, Ihre Testbarkeit Probleme. Singletons sind nicht leicht mockable für Testzwecke. Wenn dies erweist sich ein problem zu sein, ich mag, um die folgenden geringfügigen änderungen:

public class SingletonImpl {

    private static SingletonImpl instance;

    public static SingletonImpl getInstance() {
        if (instance == null) {
            instance = new SingletonImpl();
        }
        return instance;
    }

    public static void setInstance(SingletonImpl impl) {
        instance = impl;
    }

    public void a() {
        System.out.println("Default Method");
    }
}

Den zusätzlichen setInstance Methode können Sie eine mockup-Implementierung der singleton-Klasse während der Tests:

public class SingletonMock extends SingletonImpl {

    @Override
    public void a() {
        System.out.println("Mock Method");
    }

}

Funktioniert das auch mit der frühen Initialisierung Ansätze:

public class SingletonImpl {

    private static final SingletonImpl instance = new SingletonImpl();

    private static SingletonImpl alt;

    public static void setInstance(SingletonImpl inst) {
        alt = inst;
    }

    public static SingletonImpl getInstance() {
        if (alt != null) {
            return alt;
        }
        return instance;
    }

    public void a() {
        System.out.println("Default Method");
    }
}

public class SingletonMock extends SingletonImpl {

    @Override
    public void a() {
        System.out.println("Mock Method");
    }

}

Dies hat den Nachteil, entlarven Sie diese Funktion, um die normale Anwendung zu. Andere Entwickler arbeiten an diesem code könnte versucht sein, verwenden Sie die Methode setInstance zu verändern verändern eine bestimmte Funktion und verändert damit die gesamte Anwendung Verhalten, daher sollte diese Methode enthält mindestens eine gute Warnung es ist javadoc.

Dennoch für die Möglichkeit der mockup-Tests (wenn nötig), diese code-Exposition kann zu einem akzeptablen Preis zu bezahlen.

InformationsquelleAutor user3792852

Ich denke immer noch nach java 1.5, enum ist die beste verfügbare singleton-Implementierung verfügbar, da er auch dafür sorgt, dass auch im multi-threaded-Umgebungen - nur eine Instanz erstellt wird.

public enum Singleton{
INSTANCE;
}

und Sie sind fertig !!!

InformationsquelleAutor shikjohari

Die besten singleton-Muster, das ich je gesehen habe verwendet der Auftragnehmer-Schnittstelle.

• Ist es, generische und wieder verwendbare
• Es unterstützt die verzögerte Initialisierung
• Es nur synchronisiert, bis es initialisiert wurde, dann wird die Sperrung der Lieferant ersetzt wird, mit einer non-blocking-Lieferanten.

Siehe unten:

public class Singleton<T> implements Supplier<T> {

    private boolean initialized;
    private Supplier<T> singletonSupplier;

    public Singleton(T singletonValue) {
        this.singletonSupplier = () -> singletonValue;
    }

    public Singleton(Supplier<T> supplier) {
        this.singletonSupplier = () -> {
            //The initial supplier is temporary; it will be replaced after initialization
            synchronized (supplier) {
                if (!initialized) {
                    T singletonValue = supplier.get();
                    //Now that the singleton value has been initialized,
                    //replace the blocking supplier with a non-blocking supplier
                    singletonSupplier = () -> singletonValue;
                    initialized = true;
                }
                return singletonSupplier.get();
            }
        };
    }

    @Override
    public T get() {
        return singletonSupplier.get();
    }
}

InformationsquelleAutor

public class Singleton {

    private static final Singleton INSTANCE = new Singleton();

    private Singleton(){
    if (INSTANCE != null)
        throw new IllegalStateException (“Already instantiated...”);
}

    public synchronized static Singleton getInstance() { 
    return INSTANCE;

    }

}

Als wir Hinzugefügt haben, Synchronisiert, keyword-bevor getInstance, wir haben es vermieden, die race-Bedingung in dem Fall, wenn zwei threads aufrufen der getInstance zur gleichen Zeit.

InformationsquelleAutor somenath mukhopadhyay