Preguntas de la entrevista, desarrollar un modelo de caso único

Patrón único de escritura a mano

　　Durante la entrevista, le pregunté sobre el modo singleton. El modo singleton es el modo más simple, pero requiere mucho esfuerzo si quiere usarlo bien.

Modo hambriento

public staticSingleton { 
    private static Singleton = new Singleton (); 
    private Singleton () {} 
    public static getSingleton () { 
        return sinleton; 
    }

　　Esto es simple en su propósito, pero es imposible crear objetos diferidos, pero a menudo queremos que los objetos se carguen lo más tarde posible, lo que reduce la carga, por lo que el modo perezoso es el siguiente

clase pública Singleton {Singleton 
    estático privado singleton = nulo; 
    private Singleton () {} 
    public static Singleton getSingleton () { 
        if (singleton == null) { 
                singleton = new Singleton (); 
        } 
         return singleton; 
    } 
}

　Considere la escritura segura para hilos:

Public class Singleton { 
    Private static volátil Singleton singleton = nulo; 
  
    private Singleton () {} 
  
    public static Singleton getSingleton () { 
        synchronized (Singleton.class) { 
            if (singleton == null) { 
                singleton = new Singleton (); 
            } 
        } 
        return singleton; 
    }     
}

　　Escribir con hilo y eficiencia en mente

Public class Singleton { 
    Private static volátil Singleton singleton = nulo; 
     
    private Singleton () {} 
     
    public static Singleton getSingleton () { 
        if (singleton == null) { 
            synchronized (Singleton.class) { 
                if (singleton == null) { 
                    singleton = new Singleton (); 
                } 
            } 
        } 
        return singleton; 
    }     
}

　　Dos nulos son innecesarios. De hecho, la simultaneidad mejora. En el modo singleton, la situación de nuevo es muy rara. La gran mayoría de las operaciones de lectura paralela, por lo que una nula más, lo que reduce la mayoría de las operaciones de bloqueo, mejora la eficiencia de ejecución El objetivo se logró.

 

Otros pozos

El primer nivel de volatilidad es bien conocido, es decir, la modificación en la memoria de trabajo de la variable se escribirá en la memoria principal inmediatamente. Hilo exclusivo cuando se trabaja en la memoria. Los hilos principales de la memoria son compartidos. La segunda capa de volatilidad significa prohibir la optimización del pedido a partir del pedido. La seguridad del hilo no se puede garantizar antes de jdk1.5.

Patrón estático de clase interna

Entonces, ¿hay una manera simple de retrasar la carga y garantizar la seguridad del hilo? Podemos poner la instancia Singleton en una clase interna estática, lo que evita que la instancia estática cree objetos cuando se carga la clase Singleton, y debido a que la clase interna estática solo se cargará una vez, este método de escritura también es seguro para subprocesos

public class Singleton { 
    Private static class Holder { 
        private static Singleton singleton = new Singleton (); 
    } 
     
    private Singleton () {} 
         
    public static Singleton getSingleton () { 
        return Holder.singleton; 
    } 
}

　　Enumeración

enumeración pública Singleton { 
    INSTANCE; 
    nombre de cadena privado; 
    public String getName () { 
        nombre de retorno; 
    } 
    public void setName (String name) { 
        this.name = name; 
    } 
}

　　Además de la seguridad del subproceso y evitar que la reflexión llame al constructor por la fuerza, el uso de la enumeración también proporciona un mecanismo de serialización automático para evitar la creación de nuevos objetos durante la deserialización. Por lo tanto, Effective Java recomienda usar la enumeración tanto como sea posible para implementar singletons.

Resumen

Finalmente, no importa qué plan se tome, tenga en cuenta los tres puntos principales del singleton:

• A prueba de hilos
• Carga perezosa
• Seguridad de serialización y deserialización