Los subprocesos son un concepto muy importante en la programación Java. Este artículo lo explicará en detalle en forma de ejemplos. El análisis específico es el siguiente:
En primer lugar, ¿para qué sirve el bloqueo de hilos? Por ejemplo: por ejemplo, si ahora tiene 30.000 yuanes en el banco y va al banco a retirar el dinero, después de ingresar la contraseña, ya ha ingresado el monto del retiro. Por ejemplo, si ingresó 20.000, es. significa que el banco obtendrá el dinero por usted. En ese momento, su esposa también fue al banco a retirar el dinero y usted. Mi esposa también retira 20.000, porque su cuenta todavía tiene 30.000 en este momento, por lo que el banco realiza la misma operación por parte de su esposa. De esta manera, después de que ustedes dos completen sus respectivas operaciones, el banco aún debería tener 30.000 registrados en su cuenta. Un depósito de 10.000 yuanes, ¿no es genial? Para resolver este problema, utilizamos el conocimiento del bloqueo de subprocesos. Aprendamos juntos.
1. Un ejemplo de sincronización de subprocesos no controlados:
clase pública TextSync implementa Runnable{ /**Sincronización de subprocesos no controlados* @param args */ Time time = new Time(); public static void main(String[] args) { TextSync text = new TextSync(); (texto); subproceso t2 = nuevo subproceso (texto); t1.setName("t1"); t2.setName("t2"); t2.start() } @Override public void run() { time.add(Thread.currentThread().getName() }}class Time { private static int num = 0; public void add(String nombre){ try { num++; // Cuando el primer hilo se ejecuta hasta este punto, num se convierte en 1 y el primer hilo se detiene durante un segundo. // Cuando el segundo hilo se ejecuta hasta este punto, num se convierte en 2. y el segundo hilo se detiene durante un segundo. // El número del primer hilo también se convierte en 2 en este momento, por lo que el resultado final es 2; Thread.sleep(1000); catch (InterruptedException e) { e.printStackTrace() } System.out.println (name+) " es el "+num+"ésimo hilo de ejecución.");Resultado de salida:
t2 es el segundo hilo de ejecución. t1 es el segundo hilo de ejecución.
2. Sincronización de hilos
clase pública TextSynctwo implementa Runnable{ /**Sincronización de subprocesos* @param args */ Time1 time = new Time1(); public static void main(String[] args) { TextSynctwo text = new TextSynctwo(); texto); Hilo t2 = nuevo Hilo(texto); t1.setName("t1"); t1.start(); t2.start(); } @Override public void run() { time.add(Thread.currentThread().getName() }}class Time1 { private static int num = 0; sincronizado bloquea el hilo actual, que puede declararse cuando se define el método o establecerse en el método. public sincronizado void add(String name){ //sincronizado (this) {//Bloquea el hilo actual para evitar que otros hilos lo ejecuten try { num++; . printStackTrace(); } System.out.println(nombre+"es el "+num+"ésimo hilo de ejecución.");Resultado de salida:
t1 es el primer hilo de ejecución. t2 es el segundo hilo de ejecución.
3. Punto muerto
clase pública TestDeadLock implementa Runnable{ /**Deadlock* @param args */ private int flag = 0; static Object o1 = new Object() static Object o2 = new Public static void main(String[] args ) { TestDeadLock td1 = nuevo TestDeadLock(); TestDeadLock td2 = nuevo TestDeadLock(); = 1; td2.flag = 2; Hilo t1 = nuevo Hilo(td1); Hilo t2 = nuevo Hilo(t1.setName("t1"); ; t2.start(); } @Override ejecución nula pública() { System.out.println(Thread.currentThread().getName()); if(flag == 1){ sincronizado(o1){ prueba { Thread.sleep(5000 } catch (InterruptedException e) { e.printStackTrace(); } sincronizado(o2){ System.out.println("1"); sincronizado(o2){ prueba { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace() } sincronizado(o1){ System.out.println("2");4. Bloquear
clase pública TT implementa Runnable{ /**Lock* @param args */ int b = 100; public static void main(String[] args) { TT tt = new TT(); .start(); intentar { tt.m2() } atrapar (Excepción e) { e.printStackTrace(); System.out.println(tt.b); } @Override public void run() { try { m1() } catch (Exception e) { e.printStackTrace() } } void privado sincronizado m1() lanza Exception; b = 1000; Thread.sleep(5000); System.out.println("b="+b); lanzamientos privados sincronizados de void m2(). Excepción { Thread.sleep(2500); b = 2500;La salida ahora es:
1000b=1000
Se puede ver que m2 se ejecuta primero y m1 no se puede ejecutar hasta que se complete m2.
Espero que este artículo sea útil para el diseño de programación Java de todos.