El modelo Singleton es el modelo de diseño más simple entre los 23 modelos de diseño, y también se usa ampliamente en el desarrollo empresarial. La ventaja del patrón Singleton es que solo hay una instancia en el proyecto.
Características: El constructor está privatizado, el objeto está privatizado y solo proporciona una interfaz de acceso externo.
Escenarios de aplicación:
1. El sistema necesita compartir recursos: como el sistema de registro, Spring Resource Manager, etc.
2. Para controlar el uso de recursos: como el grupo de subprocesos
Aplicaciones comunes en el desarrollo de nivel empresarial y marcos comunes:
Servlets en J2EE, gerentes de recursos en primavera (es decir, frijoles), grupos de conexión de bases de datos, grupos de subprocesos, sistemas de registro, contadores de sitios web, etc.
Clasificación de patrones Singleton:
1. Modo hambriento: el modo hambriento es el modo singleton más simple para el código, pero la instancia se carga cuando la clase se inicializa. Si no se usa al instante, el sistema se cargará. El código específico es el siguiente:
clase pública Singleton {Instancia privada de Singleton Singleton = new Singleton (); private singleton () {} public static singleton getInstance () {instancia de retorno; }}2. Modo perezoso: en comparación con el modo hambriento, el modo perezoso se instancia y se coloca en la única interfaz externa para procesar, lo que realiza la carga retrasada, ahorra el tiempo de inicialización del sistema, pero hay una situación en la que los subprocesos son inseguros.
clase pública Singleton {Instancia de Singleton static privada = nulo; private singleton () {} public static singleton getInstance () {if (instance == null) {return new Singleton (); } instancia de retorno; }}3. Bloqueo de verificación doble: el modo de bloqueo de doble verificación es en realidad una actualización del modo perezoso, lo que hace que el modo perezoso sea seguro de subproceso. Nota: Hay un problema de memoria con el bloqueo de doble verificación, que puede invalidar el bloqueo de doble verificación.
clase pública Singleton {Instancia de Singleton static privada = nulo; private singleton () {} public static singleton getInStance () {if (instance == null) {sincronizado (singleton.class) {if (instance == null) {return new singleton (); }} instancia de retorno; }}4. Modo de clase interna estática: la clase interna estática tiene modos perezosos y malvados: carga tardía y tardía.
clase pública Singleton {private static class SingletAnFactory {private static singleton instancia = new Singleton (); } private singleton () {} public static singleton getInstance () {return singletOnFactory.Instance; }}5. Modo de clase de enumeración: debería ser el modo de interés único más perfecto, que no solo es seguro de subprocesos, sino que también evita los problemas de desquio y reflexión.
enum singleton {instancia; public void dosomething () {...}}Problema de detalles del patrón singleton:
1. La reflexión rompe el modo singleton: la reflexión puede destruir la implementación del modo singleton (a excepción del modo de enumeración)
/***Destruir el modo Singleton por reflexión*/public class Demo01 {public static void main (string [] args) lanza la excepción {singleton s1 = singleton.getInstance (); Singleton s2 = singleton.getInstance (); System.out.println (S1 == S2); Class <Singleton> Clazz = (Class <Singleton>) Class.Forname ("com.singleton.singleton"); Constructor <singleton> constructor = clazz.getDeClaredConstructor (nulo); constructor.setAccessible (verdadero); Singleton s3 = constructor.newinstance (); System.out.println (S1 == S3); }} class Singleton {private static singleton instancia = new Singleton (); Método privado singleton () {// para evitar que la reflexión destruya el modo de interés único, abra la sección de comentarios // if (instancia! = null) {// tire runtimeException (); //}} public singleton getinstance () {return instancia; }}De hecho, la llamada prevención significa hacer imposible crear a través de la reflexión.
2. La deserialización rompe el patrón singleton (a excepción del patrón de clase de enumeración)
/*** Deserialización rompe el patrón Singleton*/public class Demo02 {public static void main (string [] args) lanza la excepción {Singleton s1 = Singleton.getInstance (); Singleton s2 = singleton.getInstance (); System.out.println (S1 == S2); FileOutputStream fos = new FileOutputStream ("d: //test.txt"); ObjectOutputStream oos = new ObjectOutputStream (FOS); OOS.WriteObject (S1); oos.close (); fos.close (); ObjectInputStream OIS = new ObjectInputStream (new FileInputStream ("d: //test.txt")); Singleton s3 = (singleton) ois.readObject (); System.out.println (S1 == S3); }} clase Singleton implementa serializable {private static singleton instance = new Singleton (); public static singleton getInstance () {instancia de retorno; } // Deserialización predeterminada, si el objeto ya existe, este método se llamará // objeto privado readresolve () lanza ObjectStreamException {// return instancia; // //}}Estas dos situaciones se limitan a la comprensión y no se usan mucho en el proceso de desarrollo real.
En este punto, el patrón Singleton está completo.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.