Modo singleton
Visión general
Modo singleton, su definición es garantizar que solo haya una instancia de una determinada clase y proporcionar un punto de acceso global.
Caracteristicas
1. 不允许其他程序调用new对象
2. 在该类中创建对象
3. 对外提供一个可以让其他程序获取对象的方法
Por lo tanto, cuando solo se necesita un objeto de instancia en el sistema o solo se permite un punto de acceso público en el sistema, y no se puede acceder a la instancia a través de otros puntos de acceso excepto este punto de acceso público, se puede usar el modo singleton
ventaja
1. 节约系统资源、提高了系统效率
2. 能够严格的控制客户对它的访问
Desventaja
1. 会导致单例类的职责过重，违背了“单一职责原则”
2. 由于没有抽象类，所以拓展起来有一定的困难
lograr
1. 私有化该类的构造函数
2. 通过new在本类中创建一个本类对象
3. 定义一个公有的方法，将在该类中所创建的对象返回
Escritura
El modo singleton se puede escribir de cinco formas: perezoso, hambriento, bloqueo de doble verificación, clase interna estática, enumeración
Chino hambriento
public class Singleton{
private static Singleton instance = new Singleton();
private Singleton(){
}
public static Singleton getInstance(){
return instance;
}
}
ventaja
Este método es relativamente simple de implementar y la instanciación se completa cuando se carga la clase, evitando el problema de la sincronización de subprocesos.
Desventaja
Dado que se instancia cuando se carga la clase, no logra el efecto de carga diferida, lo que significa que cargaré sin ella, lo que provocará un desperdicio de memoria (este desperdicio se puede ignorar, por lo que también se recomienda este método Usado )
Si la inicialización en sí depende de otros datos, es difícil asegurarse de que los demás datos estén listos antes de que se inicialicen.
Transformación
public class Singleton{
private static Singleton instance = null;
static{
instance = new Singleton();
}
private Singleton(){
}
public static Singleton getInstance(){
return instance;
}
}
Hombre flojo
Escribir un [hilo no es seguro y no está disponible]
public class Singleton{
private static Singleton instance = null;
private Singleton(){
}
public static Singleton getInstance(){
if(instance == null) instance = new Singleton();
return instance;
}
}
Esta forma de escritura causará problemas de seguridad en los subprocesos y puede crear dos objetos al mismo tiempo
Método de escritura dos [seguridad de subprocesos, baja eficiencia, no recomendado]
public class Singleton{
private static Singleton instance = null;
private Singleton(){
}
public static synchronized Singleton getInstance(){
if(instance == null) instance = new Singleton();
return instance;
}
}
La eficiencia de ejecución es demasiado baja. Cuando cada hilo quiere obtener una instancia de la clase, el método getInstance () debe ejecutarse sincrónicamente. Este método solo necesita ejecutarse una vez, y luego desea obtener el retorno directo.
Mejora [El hilo no es seguro ni está disponible]
public class Singleton{
private static Singleton instance = null;
private Singleton(){
}
public static Singleton getInstance(){
if(instance == null) {
synchronized(Singleton.class){
instance = new Singleton();
}
}
return instance;
}
}
Puede haber un segundo hilo que ingrese al bloque de instrucciones if. Después de que se ejecute el primer hilo, el segundo hilo creará un objeto nuevamente, por lo que el gran dios escribió el bloqueo de verificación doble perezoso
Bloqueo de verificación doble [recomendado]
public class Singleton{
/**
* 懒汉式变种，属于懒汉式中最好的写法，
* 保证了：延迟加载和线程安全
*/
private static Singleton instance = null;
private Singleton(){
}
public static Singleton getInstance(){
if(instance == null) {
synchronized(Singleton.class){
if(instance == null) instance = new Singleton();
}
}
return instance;
}
}
Realizamos dos comprobaciones if (instancia == nula, para que podamos garantizar la seguridad del hilo), y devolveremos el objeto de instancia directamente cuando accedamos a él más tarde
ventaja
Seguridad del hilo, carga diferida, alta eficiencia
Desventaja
El código anterior parece perfecto, pero de hecho todavía hay un pequeño defecto: otros hilos han llamado a la clase antes de que se cargue.
Mejorar
El método anterior ha sido mejorado. Simplemente agregue la palabra clave volátil a la instrucción de instancia. La función de la palabra clave volátil es prohibir el reordenamiento de instrucciones, de modo que la operación de lectura no se permita hasta que se complete la asignación.
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;
}
}
Clase interna estática [recomendado]
public class singleton{
private Singleton(){
}
private static class SingletonHolder{
private static final Singleton INSTANCE = new Singleton();
}
public static final Singleton getInstance(){
return SingletonHolder.INSTANCE;
}
}
Cuando se carga la clase Singleton, no se creará una instancia, pero cuando se llama al método getInstance, se cargará la clase SingletonHohder para completar la instanciación del Singleton.
¿Por qué podemos garantizar la seguridad de los hilos?
Las propiedades estáticas de la clase solo se inicializarán cuando la clase se cargue por primera vez. La JVM nos ayuda a garantizar la seguridad del hilo. Cuando se inicializa la clase, otros hilos no pueden ingresar
ventaja
线程安全，延迟加载，效率高
Enumeración 【Muy recomendable】
public enum SingletonEnum{
INSTANCE;
private SingletonEnum(){
}
public void method(){
}
}
La escritura de la enumeración es muy simple, el método de acceso SingletonEnum.INSTANCE donde INSTANCE es la referencia del tipo SingletonEnum, puede llamar al método en la enumeración cuando lo obtenga
Blog de referencia
https://www.cnblogs.com/pony1223/p/7608955.html
http://blog.csdn.net/dmk877/article/details/50311791
https://www.cnblogs.com/dongyu666/p/6971783. html