Primero escriba un solo caso:
clase pública Singledemo {private static singleledemo s = null; privado singledEmo () {} public singledemo singledemo getInstance () {if (s == null) {s = new SingleDEMO (); } return s; }}Escribe una clase de prueba:
public class ThreadDemo3 {public static void main (string [] args) {singledemo s1 = singleledemo.getInstance (); SingleDEMO S2 = SingleLedemo.getInstance (); System.out.println (S2 == S2); }}El resultado en ejecución siempre es cierto, lo que significa que no hay problema en un solo hilo. Escribamos un subproceso múltiple para acceder al caso único.
Public Class ThreadTest implementa Runnable {// Almacenamiento de objetos Singleton, el uso de SET es no almacenar elementos duplicados SET PUBLIC <Singledemo> Singles = new Hashset <SingledEmo> (); @Override public void run () {// Get SingledEmo S = SingleLedemo.getInStance (); // Agregar singleton singles.add (s); }}Use acceso concurrente multiproceso a Singletons:
public class ThreadDemo3 {public static void main (string [] args) {// singledemo s1 = singleledemo.getInstance (); // Singledemo S2 = SingleLedemo.getInstance (); // System.out.println (S2 == S2); Threadtest t = new ThreadTest (); nuevo hilo (t) .Start (); nuevo hilo (t) .Start (); nuevo hilo (t) .Start (); nuevo hilo (t) .Start (); nuevo hilo (t) .Start (); nuevo hilo (t) .Start (); nuevo hilo (t) .Start (); nuevo hilo (t) .Start (); nuevo hilo (t) .Start (); System.out.println (T.Singles); }}
Los resultados de la operación son los siguientes:
[com.persagy.thread.singledemo@1bc4459, com.persagy.thread.singledemo@150bd4d]
o
[com.persagy.thread.singledemo@12b6651]
Significa que hay un problema de seguridad de acceso concurrente enhebrado, y las instancias obtenidas pueden no ser las mismas
¿Cómo resolver problemas de seguridad de hilos?
Por supuesto, se utiliza el mecanismo de bloqueo de sincronización.
Lo siguiente es una mejora en el singleton:
clase pública SingledEmo {private static singleledemo s = null; private singleledemo () {} public static sincronizado sincronizado getInstance () {if (s == null) {s = nuevo singleDEMO ();} return S;}} El problema de seguridad del hilo se resolvió después de agregar la función sincrónica
Ejecute varias veces para obtener la misma instancia, y no habrá 2 instancias.
[com.persagy.thread.singledemo@12b6651]
Sin embargo, en el caso del acceso concurrente múltiple, cada hilo debe juzgar el bloqueo cada vez que adquiere una instancia, que es relativamente baja eficiencia. Para mejorar la eficiencia, agregué un método de doble juicio para resolver el problema de la eficiencia
El código es el siguiente:
clase pública SingledEmo {private static singleledemo s = null; private singleledemo () {} public static singleledemo getInstance () {/ * Si el primer hilo obtiene el objeto de instancia del singleton, * Cuando el hilo posterior obtiene la instancia, no necesita ingresar al bloque de código de sincronización. */if (s == null) {// El bloqueo utilizado en el bloque de código de sincronización es el objeto de archivo bytecode del singleton, y este bloqueo solo se puede usar sincronizado (singledemo.class) {if (s == null) {s = new SingleDEMO ();}}} return S;}}}}}Este método resuelve el problema de seguridad del hilo de las personas perezosas y mejora la eficiencia. Sin embargo, en el desarrollo real, más personas usan personas hambrientas. Después de todo, este código es más complicado y complicado.
Lo anterior es el contenido completo de la solución perfecta para el problema de la seguridad de los hilos perezosos en el modo de diseño de un solo caso que el editor le brinda. Espero que todos apoyen a Wulin.com más ~