1. Introducción
Este resumen de mi comprensión de la comunicación entre hilos en el formato de múltiples subprocesos Java discute principalmente la comunicación entre hilos en un código combinado con texto, por lo que extraí algunos códigos de ejemplo en el libro.
2. Método de comunicación entre hilos
① Sincronización
La sincronización mencionada aquí se refiere a múltiples hilos utilizando la palabra clave sincronizada para realizar la comunicación entre hilos.
Ejemplo de referencia:
clase pública myObject {sincronizado public void Methoda () {// Do Something ...} sincronizado public void Methodb () {// haz alguna otra cosa}} public class thadsa extiende hilo {objeto privado myobject; // omitir el constructor @override public void run () {super.run (); objeto.methoda (); }} public class Threadb extiende hilo {objeto privado myobject; // omitir el constructor @Override public void run () {super.run (); objeto.methodb (); }} public class run {public static void main (string [] args) {myObject Object = new MyObject (); // El hilo A y el hilo B sostienen el mismo objeto: Object Thraina a = New Threada (Object); Threadb b = new Threadb (objeto); A.Start (); B.Start (); }}Dado que el hilo A y el hilo B sostienen el objeto del objeto de la misma clase MyObject, aunque estos dos hilos deben llamar a diferentes métodos, se ejecutan sincrónicamente. Por ejemplo, el subproceso B debe esperar a que Thread A ejecute el método MethodA () antes de poder ejecutar el método Methodb (). De esta manera, el hilo A y el hilo B realizan la comunicación.
Este método es esencialmente una comunicación de "memoria compartida". Múltiples subprocesos deben acceder a la misma variable compartida, y quien obtenga el bloqueo (obtiene derechos de acceso), puede ejecutarlo.
② Mientras el método de votación
El código es el siguiente:
import java.util.arrayList; import java.util.list; public class MyList {private list <string> list = new ArrayList <String> (); public void add () {list.add ("Elements"); } public int size () {return list.size (); }} import mylist.mylist; public class Thinda extiende el hilo {Lista de mylist privada; publicada public (Lista de MyList) {super (); this.list = list; } @Override public void run () {try {for (int i = 0; i <10; i ++) {list.add (); System.out.println ("agregado" + (i + 1) + "Elementos"); Thread.sleep (1000); }} catch (InterruptedException e) {E.PrintStackTrace (); }}} import mylist.mylist; public class Threadb extiende hilo {lista privada de mylist; public threadb (mylist list) {super (); this.list = list; } @Override public void run () {try {while (true) {if (list.size () == 5) {system.out.println ("== 5, el hilo B está listo para salir"); tirar nueva interrupciónxception (); }}} Catch (InterruptedException e) {E.PrintStackTrace (); }}} import mylist.mylist; import Extthread.threada; import Extthread.threadb; public class Test {public static void main (string [] args) {myList Service = new MyList (); ThraTA a = new ThreadA (Servicio); A.SetName ("A"); A.Start (); Threadb b = new Threadb (servicio); B.SetName ("B"); B.Start (); }}De esta manera, el hilo A cambia constantemente las condiciones, y Thread Threadb detecta constantemente si esta condición (list.size () == 5) es verdadera a través de la declaración while, realizando así la comunicación entre hilos. Pero este método desperdiciará los recursos de la CPU. La razón por la que desperdicia recursos es que cuando el planificador JVM entrega la CPU al hilo B para la ejecución, no hace ningún trabajo "útil", pero solo prueba constantemente si una determinada condición es cierta. Es similar a la vida real, alguien sigue mirando si el teléfono viene en la pantalla de su teléfono móvil, en lugar de: hacer algo más, cuando viene un teléfono, el sonar le notificará que el teléfono viene.
Mecanismo Wait/Notify
El código es el siguiente:
import java.util.ArrayList; import java.util.list; public class MyList {private static list <String> list = new ArrayList <String> (); public static void add () {list.add ("anystring"); } public static int size () {return list.size (); }} Public Class Thinde extiende el hilo {bloqueo de objeto privado; publicada public (bloqueo de objeto) {super (); this.lock = Lock; } @Override public void run () {try {sincronizado (bloqueo) {if (myList.size ()! = 5) {System.out.println ("Wait Begin" + System.CurrentTimemillis ()); Lock.wait (); System.out.println ("Wait End" + System.CurrentTimemillis ()); }}} Catch (InterruptedException e) {E.PrintStackTrace (); }}} public class Threadb extiende hilo {bloqueo de objeto privado; public Threadb (bloqueo de objeto) {super (); this.lock = Lock; } @Override public void run () {try {sincronizado (bloqueo) {for (int i = 0; i <10; i ++) {mylist.add (); if (myList.size () == 5) {Lock.Notify (); System.out.println ("notificado"); } System.out.println ("agregado" + (i + 1) + "elementos!"); Thread.sleep (1000); }}} Catch (InterruptedException e) {E.PrintStackTrace (); }}} public class run {public static void main (string [] args) {try {object lock = new Object (); Thinta a = new Threada (bloqueo); A.Start (); Thread.sleep (50); Threadb b = new Threadb (bloqueo); B.Start (); } catch (InterruptedException e) {E.PrintStackTrace (); }}}Enhebre una esperanza de esperar a que se cumpla una determinada condición antes de realizar la operación. Thread B agrega elementos a la lista y cambia el tamaño de la lista.
¿Cómo se comunican A y B? En otras palabras, ¿cómo hushon A Know That list.size () ya es 5?
Aquí usamos los métodos Wait () y notificar () de la clase de objeto.
Cuando no se cumpla la condición (list.size ()! = 5), enhebre una llamada a Wait () para abandonar la CPU y ingresa a un estado de bloqueo. --- No tome CPU como ② mientras se encuesta
Cuando se cumple la condición, el subproceso B llama a notificar () para notificar el hilo A. El llamado hilo de notificación A es para despertar el subproceso A y dejar que ingrese a un estado ejecutable.
Una ventaja de este método es que la utilización de la CPU se ha mejorado.
Pero hay algunas desventajas: por ejemplo, el hilo B se ejecuta primero, agrega 5 elementos a la vez y llame a notificar () para enviar una notificación y el subproceso A todavía se ejecuta; Cuando subhace un ejecute y llame a Wait (), nunca se despertará. Porque el hilo B ya ha emitido una notificación y no emitirá ninguna notificación en el futuro. Esto muestra que la notificación es demasiado temprana e interrumpirá la lógica de ejecución del programa.
El artículo anterior comprende profundamente el método de comunicación entre los hilos de múltiples subprocesos Java es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.