patrón de diseño Singleton apreciado

Definiciones: Asegurar una clase tiene sólo una instancia, y proporcionar un punto de acceso global a ella (para asegurar que sólo una instancia de una clase en particular, y para instanciar el ejemplo para proporcionar todo el sistema).

1. hambre al estilo chino

public class Singleton {

    private static final Singleton INSTANCE = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return INSTANCE;
    }

    public void method(){
        System.out.println("普通方法");
    }

    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
    }
}

De esta manera el trabajo de los sencillos más comúnmente utilizado. Después de la clase se carga en memoria, sólo se instanciado una vez, sólo se producirá un caso, JVM thread-safe. El único inconveniente es que, independientemente de la utilización o no, se completará cuando se crea una instancia cargado la clase.

2. El estilo perezoso

public class SingletonLazy {

    private static volatile SingletonLazy INSTANCE;

    private SingletonLazy(){}

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

    public void method(){
        System.out.println("普通方法");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            SingletonLazy instance = SingletonLazy.getInstance();
            new Thread(()-> System.out.println(instance.hashCode())).start();
        }
    }
}

Aunque en esta forma de lograr el propósito de inicializado a la carta, pero plantea un problema no seguro para subprocesos, por lo que la solución a modo de bloqueo, pero es eficiencia cae problemáticas, las otras variables necesidad de añadir la palabra clave volátil, para evitar la re-instrucción Ordenar.

3. clases internas estáticas

public class SingletonInner {

    private SingletonInner(){}

    private static class SingletonInnerHolder{
        private static final SingletonInner INSTANCE = new SingletonInner();
    }

    public static SingletonInner getInstance(){
        return SingletonInnerHolder.INSTANCE;
    }

    public void method(){
        System.out.println("普通方法");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            SingletonInner instance = SingletonInner.getInstance();
            new Thread(()-> System.out.println(instance.hashCode())).start();
        }
    }
}

Esta manera de resolver el problema de dos maneras anteriores, cuando se carga la clase SingletonInner, no se cargarán las clases internas SingletonInnerHolder, solamente llamando getInstance () el tiempo se cargará, ambos llegaron a la carga lenta, y para asegurarse de que sólo una instancia.

4. enumeración

public enum  SingletonEnum {

    INSTANCE;

    public void method(){
        System.out.println("普通方法");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->              System.out.println(SingletonEnum.INSTANCE.hashCode())).start();
        }
    }
}

De esta manera no sólo puede resolver el problema de la sincronización de hilos, sino también para evitar de-serialización, porque no hay ningún constructor de la clase de enumeración.