In dieser Zusammenfassung meines Verständnisses der Kommunikation zwischen Threads im Java-Multi-Thread-Format wird hauptsächlich die Kommunikation zwischen Threads in einem mit Text hergestellten Code erörtert. Daher habe ich einige Beispielcodes in das Buch ausgerichtet, und der spezifische Inhalt lautet wie folgt
① Synchronisation
Die hier genannte Synchronisation bezieht sich auf mehrere Threads, die das synchronisierte Schlüsselwort mit der Kommunikation zwischen Threads realisieren.
Referenzbeispiel:
public class myObject {synchronisierte public void methoda () {// etwas tun ....} synchronisierte public void methodb () {// etwas anderes Ding}} öffentliche Klasse Threada erweitert Thread {private myObject Object; // Der Konstruktor @Override Public void Run () {super.run () auslassen; Object.Methoda (); }} public class Thread erweitert Thread {private myObject Object; // Der Konstruktor @Override public void run () {Super.run (); Object.Methodb (); }} public class run {public static void main (string [] args) {myObject Object = new myObject (); // Thread A und Thread B halten dasselbe Objekt: Objekt Threada a = new Threada (Objekt); Faden B = neuer Taste (Objekt); A.Start (); b.Start (); }}Da Thread A und Thread B das Objektobjekt derselben MyObject -Klasse enthalten, müssen diese beiden Threads unterschiedliche Methoden aufrufen, aber sie werden synchron ausgeführt. Zum Beispiel muss Thread B warten, bis Thread A die Methode () () ausführen kann, bevor die Methodeb () -Methode ausgeführt wird. Auf diese Weise realisieren Thread A und Thread B die Kommunikation.
Diese Methode ist im Wesentlichen die Kommunikation "Shared Memory". Mehrere Threads müssen auf die gleiche gemeinsam genutzte Variable zugreifen, und wer die Sperre erhält (erhält Zugriffsrechte), kann sie ausführen.
② Während Wahlverfahren
Der Code ist wie folgt:
Java.util.ArrayList importieren; java.util.list; öffentliche Klasse mylist {private list <string> list = new ArrayList <string> (); public void add () {list.add ("Elemente"); } public int size () {return list.size (); }} import myList.mylist; public class Threada erweitert Thread {private myList list; public threada (myListliste) {super (); this.list = list; } @Override public void run () {try {for (int i = 0; i <10; i ++) {list.add (); System.out.println ("hinzugefügt" + (i + 1) + "Elemente"); Thread.sleep (1000); }} catch (interruptedException e) {e.printstacktrace (); }}} import myList.mylist; public class Thread erweitert Thread {private myList list; public taste (myList list) {super (); this.list = list; } @Override public void run () {try {while (true) {if (list.size () == 5) {System.out.println ("== 5, Thread B ist bereit zu beenden"); neue InterruptedException () werfen; }}} catch (interruptedException e) {e.printstacktrace (); }}} import myList.mylist; importThread.threada; importe exthread.threadb; public class test {public static void main (string [] args) {myList service = new myList (); Threada a = neuer Threada (Service); A.SetName ("a"); A.Start (); Faden B = neuer Taste (Service); B.SetName ("B"); b.Start (); }}Auf diese Weise ändert sich der Thread A ständig die Bedingungen und erkennen ständig, ob diese Bedingung (list.size () == 5) durch die while -Anweisung wahr ist, wodurch die Kommunikation zwischen Threads realisiert wird. Diese Methode verschwendet jedoch CPU -Ressourcen. Der Grund, warum es Ressourcen verschwendet, ist, dass der JVM -Scheduler, der die CPU für die Ausführung mit Thread B befasst, keine "nützliche" Arbeit erledigt, sondern nur ständig testet, ob eine bestimmte Bedingung wahr ist. Es ist ähnlich wie im wirklichen Leben. Jemand schaut immer wieder, ob das Telefon auf den Bildschirm seines Handys steht, anstatt: etwas anderes zu tun, wenn ein Telefon kommt, wird das Klingeln ihm benachrichtigen, dass das Telefon kommt. In Bezug auf die Auswirkungen von Thread -Umfragen siehe: Was sind die Folgen eines Threads, der eine tote Schleife in Java ausführt
③Wait/Benachrichtigen Sie den Mechanismus
Der Code ist wie folgt:
Java.util.ArrayList importieren; java.util.list; öffentliche Klasse mylist {private statische Liste <string> list = new ArrayList <string> (); public static void add () {list.add ("modusstring"); } public static int size () {return list.size (); }} public class Threada erweitert Thread {private Object Lock; public threada (Object Lock) {Super (); this.lock = lock; } @Override public void run () {try {synchronized (lock) {if (myList.size ()! lock.wait (); System.out.println ("Wait End" + System.currentTimemillis ()); }}} catch (interruptedException e) {e.printstacktrace (); }}} public class Faden erweitert Thread {private Object Lock; public taste (Object Lock) {Super (); this.lock = lock; } @Override public void run () {try {synchronized (lock) {for (int i = 0; i <10; i ++) {myList.add (); if (myList.size () == 5) {lock.notify (); System.out.println ("benachrichtigt"); } System.out.println ("hinzugefügt" + (i + 1) + "Elemente!"); Thread.sleep (1000); }}} catch (interruptedException e) {e.printstacktrace (); }}} public class run {public static void main (String [] args) {try {Object lock = new Object (); Threada a = neuer Threada (Sperre); A.Start (); Thread.sleep (50); Faden B = neuer Taste (Sperre); b.Start (); } catch (interruptedException e) {e.printstacktrace (); }}}Thread A muss warten, bis eine bestimmte Bedingung erfüllt wird, bevor die Operation durchgeführt wird. Thread B fügt der Liste Elemente hinzu und ändert die Größe der Liste.
Wie kommunizieren A und B? Mit anderen Worten, wie weiß Thread A diese Liste. Gröze () ist bereits 5?
Hier verwenden wir die Methoden Wait () und benachrichtigen () der Objektklasse.
Wenn die Bedingung nicht erfüllt ist (list.size ()! = 5), tauchen Sie auf. --- Nehmen Sie die CPU nicht wie ②, während Sie befragten
Wenn die Bedingung erfüllt ist, ruft Thread B auf, benachrichtigen (), um Thread A zu benachrichtigen. Der sogenannte Benachrichtigungs-Thread A besteht darin, den Thread A aufzuwecken und ihn einen ausgeführten Zustand einzugeben.
Ein Vorteil dieser Methode ist, dass die CPU -Nutzung zugenommen hat.
Es gibt jedoch einige Nachteile: Zum Beispiel führt Thread B zuerst aus, fügt 5 Elemente gleichzeitig hinzu und Anrufe benachrichtigen (), um eine Benachrichtigung zu senden, und Thread A wird noch ausgeführt. Wenn Thread A ausgeführt und Anrufe warten (), wird er niemals erweckt. Weil Thread B bereits eine Benachrichtigung herausgegeben hat und in Zukunft keine Benachrichtigung herausgibt. Dies zeigt, dass die Benachrichtigung zu früh ist und die Ausführungslogik des Programms stört.
Das obige dreht sich alles um diesen Artikel. Ich hoffe, dass es für alle hilfreich sein wird, Java -Programme zu lernen.