java - patron - Singleton lazy vs ansioso instanciación

singleton java explicacion

Question

Si un singleton se implementa de la siguiente manera,

class Singleton {
    private static Singleton instance = new Singleton();

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

¿En qué se diferencia esta implementación del enfoque de inicialización diferida? En este caso, la instancia se creará cuando la clase se cargue y la clase se cargue solo en el primer uso activo (por ejemplo, Singleton.getInstance () no cuando declare, por ejemplo, Singleton singleton = null;)

Incluso con un enfoque de inicialización lento, la instancia se crea en la llamada a getInstance ()

¿Me estoy perdiendo de algo?

Answer 1

Con la inicialización perezosa, creará la instancia solo cuando sea necesaria y no cuando se cargue la clase. Así que escapas de la creación de objetos innecesarios. Dicho esto, hay otras cosas a considerar también. En la inicialización perezosa, se proporciona una API pública para obtener la instancia. En un entorno de subprocesos múltiples, plantea desafíos para evitar la creación innecesaria de objetos. Usted pone bloques de sincronización, lo que plantea un bloqueo innecesario que debe hacerse para verificar si el objeto ya está creado. Así que se convierte en un problema de rendimiento en este caso.

Entonces, si está seguro de que crear su objeto no va a tomar ninguna memoria significativa y casi siempre se usará en su aplicación, entonces es bueno crearlo en la inicialización estática. Además, no olvide hacer que su instancia sea definitiva en este caso, ya que se asegura de que la creación del objeto se refleje correctamente y en su totalidad en la memoria principal, lo que es importante en un entorno de subprocesos múltiples.

Consulte este tutorial de IBM en Singleton + Lazy Loading + Caso de entorno multihilo

=============== Editar el 09/09/2018 ====================

También debe ver el patrón de creación de objetos bajo demanda here .

Answer 2

En primer lugar, se sobreutiliza el patrón singleton. Lo que realmente desea hacer si quiere "uno de algo" es declararlo un singleton en el marco de su elección DI. Esto es efectivamente un singleton ansioso de configuración, y libera opciones para inyectar simulacros para realizar las pruebas adecuadas.

¿Por qué no carga perezosa? A menos que su clase tenga una rutina de inicialización masiva en la construcción (que yo diría que también es un anti-patrón), no hay beneficios y hay muchos inconvenientes para la carga perezosa. Solo está agregando complejidad y posiblemente rompiendo su programa si no se realiza correctamente. La forma correcta (si es necesario) es utilizar el idioma del titular de la Inicialización bajo demanda.

Answer 3

Para la instancia de singleton de carga lenta, estoy usando como se muestra a continuación.

class Singleton {
private static Singleton instance;
private Singleton(){

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

Answer 4

Por las razones que mencionas, esta es una manera más complicada de hacer lo mismo que

enum Singleton {
    INSTANCE;
}

El uso de la inicialización diferida solo es útil si le preocupa que la clase pueda iniciarse pero no desea cargar el singleton en ese momento. Para la mayoría de las situaciones esto es sobre matar.

Nota: Solo hacer referencia a la clase no inicializa la clase.

por ejemplo, supongamos que tiene una clase mal escrita que no se puede iniciar hasta que se establezca alguna condición. En este caso, n debe ser distinto de cero.

public class Main {
    public static void main(String ... args) {
        Class c= LazyLoaded.class;
        System.out.println(c);
    }

    static class LazyLoaded {
        static int n = 0;
        static {
            System.out.println("Inverse "+1000/n);
        }
    }
}

huellas dactilares

class Main$LazyLoaded

Answer 5

Puede llamar a cualquier otro método estático o variable miembro estática también para cargar la instancia de singleton.

class Logger {     
   private static Logger instance = new Logger(); 
   public static String LOG_LINE_SEPERATOR =  
      System.getProperty("line.separator");
   public static Logger getInstance() {  
          return instance;     
   } 

   public static String logPattern() {
       return null;
   }
} 

...

Logger.LOG_LINE_SEPERATOR; // load Logger instance or
Logger.logPattern(); // load Logger instance