La colegiala preguntó sobre el modelo singleton, usé la explicación más fácil de entender para dejarla aprender

Prefacio

Ayer, la niña de la escuela se quejó de los 23 patrones de diseño de Java en la clase profesional. Ella preguntó: Los 23 patrones de diseño son cada vez más confusos, especialmente el patrón singleton, ¿hay alguna forma de descifrarlo ? Le dije que hay muchos 23 patrones de diseño en Java. Es importante recoger los puntos clave de conocimiento y combinarlos con ejemplos de programas para recordar. Especialmente después de aprender un patrón de diseño usted mismo, es fácil de dominar . Le expliqué cómo aprender el patrón singleton. Finalmente ella se rió, "lo entiendo".

Para los 23 patrones de diseño en Java, todos los que solo contactan pueden sentir que hay demasiados patrones de diseño y surge la idea de no querer aprender, especialmente cuando se contactan por primera vez. Así que escribí este artículo para explicar el patrón singleton en el lenguaje más común para ayudar a todos a entender.

El título del artículo es solo un truco. Como aprendiz que ama la tecnología de la comunicación, deberíamos tener los pies en la tierra, ¡así que te garantizo que el contenido del artículo es un producto seco!

Escena aplicable

Un objeto debe crearse y destruirse con frecuencia, y el rendimiento no puede optimizarse cuando se crea o destruye. Por ejemplo, la papelera de reciclaje en el sistema de Windows está en modo singleton. Abra una papelera de reciclaje y luego abra una papelera de reciclaje después del cierre.

Hambriento

Crear activamente referencias estáticas privadas para instancias. El singleton ya existe antes de la llamada.

Ventajas: simple y conveniente, hilo seguro

Desventajas: si no se llama al objeto de instancia, provocará un desperdicio de recursos de memoria

public class Singleton1 {
    //饿汉模式，天然线程安全

    // 指向自己实例的私有静态引用，主动创建
    private static Singleton1 singleton1 = new Singleton1();

    // 私有的构造方法
    private Singleton1(){

    }

    // 以自己实例为返回值的静态的公有方法，静态工厂方法
    public static Singleton1 getSingleton1(){
      return singleton1;
    }
}

Perezoso

Cree un objeto de instancia cuando se le llame. Solo cuando se llama, el singleton se inicializa.

Ventajas: simple y conveniente, no cree objetos cuando no esté en uso

Desventajas: el subproceso no es seguro. En el caso de varios subprocesos, si un subproceso cumple con la condición de juicio, otro subproceso también entra en la condición y se pueden generar objetos de instancia múltiple

public class Singleton2 {
  //懒汉式
  private static Singleton2 singleton2;
  private Singleton2(){

  }
  public static Singleton2 getSingleton2(){
    if(singleton2 == null){
      singleton2 = new Singleton2();
    }
    return singleton2;
  }

}

Modo de bloqueo único

Utilice sincronizado para modificar el método getSingleton ()

Ventajas: seguridad del hilo

Desventajas: granularidad, gran impacto en el rendimiento del programa

public class Singleton4 {
  private static Singleton4 singleton4 = null;

  private Singleton4(){

  }

  public static synchronized Singleton4 getSingleton4() {
    if(singleton4 == null){
      singleton4 = new Singleton4();
    }
    return singleton4;
  }
}

Juicio de doble bloqueo

Cree un bloqueo estático y use dos juicios if

Ventajas: seguridad de subprocesos, garantizar el rendimiento del programa y ahorrar recursos

public class Singleton3 {

  //程序运行时创建一个静态只读的进程辅助锁
  private static Object syncRoot = new Object();

  private static Singleton3 singleton3;

  private Singleton3(){

  }

  public static Singleton3 getSingleton3() {
    if(singleton3 == null){
      //先判断是否存在
      synchronized (syncRoot){
        if(singleton3 == null){
          singleton3 = new Singleton3();
        }
      }
    }
    return singleton3;
  }
}

Clase interna estática

Ventajas: no solo logra la seguridad del hilo, sino que también evita el impacto en el rendimiento del mecanismo de sincronización

public class Singleton6 {
  private static class LazyHolder{
    private static final Singleton6 singleton6 = 
        new Singleton6();
  }
  private Singleton6(){
    
  }
  public static final Singleton6 getSingleton6(){
    return LazyHolder.singleton6;
  }
}

Registro

Mantuvo un conjunto de instancias de clase singleton, coloque estas instancias en un Mapa, para instancias ya registradas, regrese directamente del Mapa, si no está registrado, regístrese primero, luego regrese

import java.util.HashMap;
import java.util.Map;

public class Singleton5 {
  private static Map<String,Singleton5>
  map = new HashMap<>();
  static {
    Singleton5 singleton5 = new Singleton5();
    map.put(singleton5.getClass().getName(),
        singleton5);
  }
  private Singleton5(){

  }
  public static Singleton5 getSingleton5(
      String name){
    if(name == null){
      name = Singleton5.class.getName();
    }
    if(map.get(name) == null){
      try {
        map.put(name,(Singleton5) Class.forName(name).newInstance());
      } catch (InstantiationException e) {
        e.printStackTrace();
      } catch (IllegalAccessException e) {
        e.printStackTrace();
      } catch (ClassNotFoundException e) {
        e.printStackTrace();
      }
    }
    return map.get(name);
  }
}

Las ventajas y desventajas del patrón singleton

Ventaja

1. Ahorre espacio en la memoria, solo hay un objeto en la memoria

2. Reducción de la sobrecarga del rendimiento del sistema.

• Por ejemplo, cuando un objeto requiere muchos recursos, como la configuración de lectura, genera otros objetos dependientes. Un objeto de instancia se genera directamente cuando se inicia la aplicación.

3. Evitar la ocupación múltiple de recursos

• Por ejemplo, para escribir un archivo, porque solo hay una instancia, evite escribir en el mismo archivo al mismo tiempo.

4. Se pueden establecer puntos de acceso global en el sistema para optimizar y acceder a recursos compartidos.

• Por ejemplo, diseñe un caso único, responsable del procesamiento de todas las tablas de datos en el sistema.

Desventajas

1. El modo singleton generalmente no tiene interfaz, y la expansión es difícil a menos que se modifique el código.

2. Si un objeto singleton contiene un Contexto, es fácil causar una pérdida de memoria.

Resumen

El patrón Singleton es uno de los patrones de diseño de Java 23. El modo singleton es adecuado para escenarios en los que los objetos deben crearse y destruirse con frecuencia y el rendimiento no puede optimizarse .

Este artículo presenta los estilos hambrientos, perezosos y de registro en el modelo singleton . Entre ellos, los chinos hambrientos y los chinos perezosos deben centrarse en el aprendizaje y la comprensión. El estilo hambriento es seguro para subprocesos naturales, mientras que los subprocesos estilo perezoso no son seguros, por lo que conduce al modo de bloqueo único estilo perezoso , juicio de doble bloqueo y clases internas estáticas .