La comunicación de subprocesos se utiliza para garantizar la operación coordinada de los subprocesos. En general, la comunicación de hilos debe considerarse al hacer sincronización de hilos.
1. Comunicación tradicional de hilos
Por lo general, se utilizan tres métodos proporcionados por la clase ObjectLT:
Estos tres métodos deben ser llamados por el objeto Monitor de sincronización y se dividen en dos situaciones:
Cuando los métodos de sincronización, dado que el monitor de sincronización es este objeto, estos tres métodos pueden llamarse directamente.
Los ejemplos son los siguientes:
clase pública syncMethodthreadCommunication {static class datawrap {int data = 0; bandera booleana = falso; public sincronizado void addthreada () {if (flag) {try {wait (); } catch (InterruptedException e) {E.PrintStackTrace (); }} datos ++; System.out.println (Thread.CurrentThread (). GetName () + "" + datos); bandera = verdadero; notificar(); } public sincronizado void addthreadb () {if (! flag) {try {wait (); } catch (InterruptedException e) {E.PrintStackTrace (); }} datos ++; System.out.println (Thread.CurrentThread (). GetName () + "" + datos); bandera = falso; notificar(); }} La clase Static Thinda extiende el hilo {datos privados de DataWrap; public Thinda (DataWrap DataWrap) {this.data = datawrap; } @Override public void run () {for (int i = 0; i <10; i ++) {data.addthreada (); }}} La clase estática Threadb extiende el hilo {datos privados de DataWrap; public Threadb (DataWrap DataWrap) {this.data = datawrap; } @Override public void run () {for (int i = 0; i <10; i ++) {data.addthreadb (); }}} public static void main (string [] args) {// Implementar dos subprocesos para agregar datos a su vez datawrap datawrap = newAwrap (); new Thinda (DataWrap) .Start (); new Threadb (DataWrap) .Start (); }}Al sincronizar los bloqueos de código, debe usar el objeto Monitor para llamar a estos tres métodos.
Los ejemplos son los siguientes:
clase pública SyncblockThreadComminication {static class datawrap {boolean flag; datos int; } La clase Static Thinda extiende el hilo {DataWrap DataWrap; public Thinta (DataWrap DataWrap) {this.datawrap = datawrap; } @Override public void run () {for (int i = 0; i <10; i ++) {sincronizado (datawrap) {if (datawrap.flag) {try {datawrap.wait (); } catch (InterruptedException e) {E.PrintStackTrace (); }} datawrap.data ++; System.out.println (getName () + "" + datawrap.data); datawrap.flag = true; datawrap.notify (); }}}}} La clase estática Threadb extiende el hilo {datawrap dataWrap; public Threadb (DataWrap DataWrap) {this.datawrap = datawrap; } @Override public void run () {for (int i = 0; i <10; i ++) {sincronizado (datawrap) {if (! Datawrap.flag) {try {datawrap.wait (); } catch (InterruptedException e) {E.PrintStackTrace (); }} datawrap.data ++; System.out.println (getName () + "" + datawrap.data); datawrap.flag = false; datawrap.notify (); }}}} public static void main (String [] args) {// Implementar dos subprocesos para agregar datos a su vez DataWrap DataWrap = newAwrap (); new Thinda (DataWrap) .Start (); new Threadb (DataWrap) .Start (); }}2. Use la condición para controlar la comunicación de subprocesos
Al usar un objeto de bloqueo para garantizar la sincronización, se utiliza un objeto de condición para garantizar la coordinación.
Los ejemplos son los siguientes:
import java.util.concurrent.locks.condition; import java.util.concurrent.locks.lock; import java.util.concurrent.locks.reentrantlock; import com.sun.media.sound.riffinvalidAdataException; import javafx.scene.chart.piechart.data; public syncLocktheadcommunation Datawrap {int data; bandera booleana; bloqueo final privado bloqueo = nuevo reentrantlock (); condición final privada condición = bloqueo.newcondition (); public void addthreada () {Lock.lock (); Pruebe {if (flag) {try {condición.await (); } catch (InterruptedException e) {E.PrintStackTrace (); }} datos ++; System.out.println (Thread.CurrentThread (). GetName () + "" + datos); bandera = verdadero; condición.signal (); } Finalmente {Lock.unlock (); }} public void addthreadb () {Lock.lock (); intente {if (! } catch (InterruptedException e) {E.PrintStackTrace (); }} datos ++; System.out.println (Thread.CurrentThread (). GetName () + "" + datos); bandera = falso; condición.signal (); } Finalmente {Lock.unlock (); }}} La clase estática Thinda extiende el hilo {datawrap dataWrap; public Thinta (DataWrap DataWrap) {this.datawrap = datawrap; } @Override public void run () {for (int i = 0; i <10; i ++) {datawrap.addthreada (); }}} La clase estática Threadb extiende el hilo {datawrap dataWrap; public Threadb (DataWrap DataWrap) {this.datawrap = datawrap; } @Override public void run () {for (int i = 0; i <10; i ++) {datawrap.addthreadb (); }}} public static void main (string [] args) {// Implementar dos subprocesos para agregar datos a su vez datawrap datawrap = newAwrap (); new Thinda (DataWrap) .Start (); new Threadb (DataWrap) .Start (); }}El await (), singal () y singalall () del objeto de condición corresponde a los métodos Wait (), notify () y notifyall () respectivamente.
3. Use la cola de bloqueo Bloquingqueue para controlar la comunicación de hilos
Bloquingqueue es una subterfaz de la interfaz de la cola, que se usa principalmente para la comunicación de subprocesos. Tiene una característica: cuando el hilo del productor intenta colocar un elemento en el bloqueo de bloqueo, si la cola está llena, el hilo está bloqueado; Cuando el hilo del consumidor intenta sacar el elemento de la Bloquingqueue, si la cola está vacía, el hilo está bloqueado. Estas dos características corresponden a dos métodos que admiten el bloqueo, pon (e e) y tomar ()
Los ejemplos son los siguientes:
import java.util.concurrent.ArrayBlockingqueue; import java.util.concurrent.blockingqueue; public class BloquingqueUethreadCommitation {static class datawrap {int data; } La clase Static Thinda extiende el hilo {privado Bloquingqueue <TataWrap> Bloquingqueue; publicada public (Bloquingqueue <TataWrap> Bloquingqueue, nombre de cadena) {super (nombre); this.blockingqueue = Bloquingqueue; } @Override public void run () {for (int i = 0; i <100; i ++) {try {datawrap datawrap = blowingqueue.take (); datawrap.data ++; System.out.println (getName () + "" + datawrap.data); dormir (1000); } catch (InterruptedException e) {E.PrintStackTrace (); }}}}} La clase estática Threadb extiende el hilo {private Bloquingqueue <DataWrap> Bloquingqueue; DataWrap privado DataWrap; public Threadb (Bloquingqueue <TataWrap> Bloquingqueue, DataWrap DataWrap, String Name) {super (nombre); this.blockingqueue = Bloquingqueue; this.datawrap = dataWrap; } @Override public void run () {for (int i = 0; i <100; i ++) {try {datawrap.data ++; System.out.println (getName () + "" + datawrap.data); BLOCKINGQUEUE.PUT (DataWrap); dormir (1000); } catch (InterruptedException e) {E.PrintStackTrace (); }}}} public static void main (string [] args) {/// Implementar dos hilos para agregar datos a su vez DataWrap DataWrap = new DataWrap (); BLOCKINGQUEUE <TATAWRAP> BLOCKINGQUEUE = new ArrayBlockingqueue <> (1); nuevo thinga (Bloquingqueue, "Consumer"). Start (); nuevo Threadb (Bloquingqueue, DataWrap, "Productor"). Start (); }}Bloquingqueue tiene cinco clases de implementación:
ArrayBlockingqueue Bloquingqueue Queue basada en la implementación de la matriz
Linked Blokingqueue Bloquingqueue Queue basada en la lista vinculada
Los elementos en PriorityBlockingqueue deben implementar la interfaz comparable, y el orden de los elementos se personaliza ordenado por comparador.
Synchronousqueue sincroniza la cola, que requiere que las operaciones de acceso en la cola deben realizarse alternativamente.
Los elementos de recolección de Delayqueue deben implementar la interfaz de retraso, y los elementos en la cola se ordenan de acuerdo con el valor de retorno del método de interfaz de retraso getDelay ().
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.