Los puntos principales del patrón singleton

El modo singleton pertenece al modo de creación

Tres puntos principales:

Solo puede haber una instancia de una clase
Debe crear esta instancia por sí mismo
Debe proporcionar esta instancia a todo el sistema por sí solo

Características del modo singleton

Una clase singleton solo puede tener una instancia
La clase Singleton debe crear su propia instancia única
La clase Singleton debe proporcionar esta instancia a todos los demás objetos.

Singleton chino hambriento

Seguro para subprocesos, fácil de implementar.
Ventajas: sin bloqueos, alta eficiencia de ejecución.
Desventajas: la clase se inicializa cuando se carga, lo que desperdicia memoria

public class Singleton {
    
    

    private final static Singleton SINGLETON = new Singleton();

    private Singleton() {
    
    

    }

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

Otra implementación:

public class Singleton {
    
    

    private static Singleton instance;

    static {
    
    
        instance = new Singleton();
    }

    private Singleton() {
    
    

    }

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

Singleton perezoso

Uno: hombre perezoso, el hilo no es seguro.

Fácil de implementar,
sin bloqueos, inseguro en situaciones de subprocesos múltiples

public class Singleton {
    
    

    private static Singleton instance;

    private Singleton() {
    
    
    }

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

Dos: hombre perezoso, seguro para subprocesos

Simple de implementar y seguro para subprocesos.
Ventajas: Inicializar solo cuando se llama por primera vez, evitando el consumo de memoria.
Desventajas: Se agrega la palabra clave sincronizada, lo cual es ineficiente

public class Singleton {
    
    

    private static Singleton instance;

    private Singleton() {
    
    
    }

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

Tres: estilo perezoso, el hilo no es seguro

Simple de implementar, inseguro para hacer
un singleton

public class Singleton {
    
    

    private static Singleton instance;

    private Singleton() {
    
    
    }

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

Cuatro: estilo perezoso, bloqueo de doble verificación / bloqueo de doble verificación

Desde JDK1.5,
seguridad de subprocesos, la implementación es más complicada.
Ventajas: seguridad de subprocesos, carga diferida, mayor eficiencia.
Nota: la modificación de palabras clave volátiles es fundamental

public class Singleton {
    
    

    private static volatile Singleton instance;

    private Singleton () {
    
    
    }

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

Cinco: clase interna perezosa y estática

Ventajas: seguridad de subprocesos, carga diferida, alta eficiencia
Principio: Las propiedades estáticas de la clase solo se inicializarán cuando la clase se cargue por primera vez. Aquí, JVM nos ayuda a garantizar la seguridad de los subprocesos. Cuando se inicializa la clase, otros subprocesos no pueden entrar.

public class Singleton {
    
    

    private Singleton() {
    
    
    }

    private static class LazySingletonInstance {
    
    
        private static final Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
    
    
        return LazySingletonInstance.instance;
    }
}

Seis: hombre perezoso, enumeración

Desde JDK1.5,
seguridad de subprocesos e implementación simple
Ventajas: se admite un mecanismo de serialización automático más conciso y se evitan absolutamente las instancias múltiples

public enum  Singleton {
    
    
    INSTANCE;
    public void whateverMethod() {
    
    

    }
}

para resumir

En términos generales, no se recomienda utilizar el primer, segundo y tercer método. Se recomienda utilizar el método del hombre hambriento. El quinto método de clase interna estática solo se usa cuando el efecto de carga diferida se debe realizar claramente. Si se trata de deserialización para crear un objeto, puede probar el sexto método de enumeración. Si tiene otras necesidades especiales, puede considerar usar el cuarto método de bloqueo de verificación doble

Solo hay un patrón de diseño de Java para usted en este mundo: patrón singleton

Modo singleton