1. Introduction
Ce résumé de ma compréhension de la communication entre les threads au format multithread Java examine principalement la communication entre les fils dans un code combiné avec du texte, j'ai donc extrait quelques exemples de codes dans le livre.
2. Méthode de communication entre les threads
① Synchronisation
La synchronisation mentionnée ici fait référence à plusieurs threads à l'aide du mot-clé synchronisé pour réaliser la communication entre les threads.
Exemple de référence:
classe publique MyObject {synchronisé public void methoda () {// faire quelque chose ....} public synchronisé public void methodb () {// faire une autre chose}} public class threada étend thread {private myObject object; // omettre le constructeur @Override public void run () {super.run (); object.methoda (); }} classe publique Threadb étend Thread {private myObject Object; // omettre le constructeur @Override public void run () {super.run (); object.Methodb (); }} public class run {public static void main (string [] args) {myObject object = new myObject (); // Thread A et Thread B maintiennent le même objet: objet Threada a = new Threada (objet); ThreadB b = new ThreadB (objet); a.start (); b.start (); }}Étant donné que le thread A et le thread B maintiennent l'objet objet de la même classe MyObject, bien que ces deux threads doivent appeler différentes méthodes, elles sont exécutées de manière synchrone. Par exemple, le thread B doit attendre le thread A pour exécuter la méthode Methoda () avant de pouvoir exécuter la méthode MethodB (). De cette façon, le fil A et le fil B réalisent la communication.
Cette méthode est essentiellement la communication "mémoire partagée". Plusieurs threads doivent accéder à la même variable partagée et quiconque obtient le verrou (obtient les droits d'accès), peut l'exécuter.
② Plain de la méthode d'interrogation
Le code est le suivant:
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 threada étend Thread {private myList list; public threada (myList list) {super (); this.list = list; } @Override public void run () {try {for (int i = 0; i <10; i ++) {list.add (); System.out.println ("ajouté" + (i + 1) + "éléments"); Thread.Sleep (1000); }} catch (InterruptedException e) {e.printStackTrace (); }}} import myList.mylist; public class threadb étend Thread {private myList list; public threadb (myList list) {super (); this.list = list; } @Override public void run () {try {while (true) {if (list.size () == 5) {System.out.println ("== 5, thread b est prêt à sortir"); Jetez une nouvelle interruption (); }}} 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 (); Threada a = new Threada (service); A.SetName ("A"); a.start (); ThreadB b = new ThreadB (service); B.SetName ("B"); b.start (); }}De cette façon, le thread a constamment modifie les conditions, et Thread Threadb détecte constamment si cette condition (List.Size () == 5) est vraie à travers l'instruction WHNE, réalisant ainsi la communication entre les threads. Mais cette méthode gaspillera les ressources CPU. La raison pour laquelle il gaspille les ressources est que lorsque le planificateur JVM remet le CPU au thread B pour l'exécution, il ne fait aucun travail "utile", mais teste constamment si une certaine condition est vraie. C'est similaire à la vraie vie, quelqu'un continue de voir si le téléphone arrive à l'écran de son téléphone portable, au lieu de: faire autre chose, quand un téléphone arrivera, la sonnerie lui informera que le téléphone arrive.
Mécanisme d'Oweït / d'information
Le code est le suivant:
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 (); }} classe publique Threada étend Thread {Lock d'objet privé; public threada (objet Lock) {super (); this.lock = lock; } @Override public void run () {try {synchronisé (lock) {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 (); }}} classe publique Threadb étend Thread {Lock d'objet privé; public ThreadB (objet Lock) {super (); this.lock = lock; } @Override public void run () {try {synchronisé (lock) {for (int i = 0; i <10; i ++) {myList.add (); if (myList.size () == 5) {Lock.Notify (); System.out.println ("notifié"); } System.out.println ("ajouté" + (i + 1) + "Elements!"); Thread.Sleep (1000); }}} catch (InterruptedException e) {e.printStackTrace (); }}} public class run {public static void main (string [] args) {try {object lock = new object (); Threada a = new Threada (Lock); a.start (); Thread.Sleep (50); ThreadB b = new ThreadB (Lock); b.start (); } catch (InterruptedException e) {e.printStackTrace (); }}}Fixez-vous à attendre une certaine condition pour être satisfaite avant d'effectuer l'opération. Le thread B ajoute des éléments à la liste et modifie la taille de la liste.
Comment A et B communiquent-ils? En d'autres termes, comment le thread A sait-il que la liste.size () est déjà 5?
Ici, nous utilisons les méthodes d'attente () et de notifier () de la classe d'objets.
Lorsque la condition n'est pas remplie (List.Size ()! = 5), Fiffez un appels Wait () pour abandonner le CPU et entre dans un état de blocage. --- Ne vous occupez pas de processe
Lorsque la condition est remplie, le thread B appelle Notify () pour notifier le thread A. Le soi-disant thread de notification A consiste à réveiller le thread A et à le laisser entrer un état de course.
Un avantage de cette méthode est que l'utilisation de la processeur a augmenté.
Mais il y a quelques inconvénients: par exemple, Thread B s'exécute d'abord, ajoute 5 éléments en même temps et appelle Notify () pour envoyer une notification et le thread a est toujours exécuté; Lorsque le thread a exécute et appelle attendre (), il ne sera jamais éveillé. Parce que le thread B a déjà émis une notification et ne publiera aucune notification à l'avenir. Cela montre que la notification est trop tôt et perturbera la logique d'exécution du programme.
L'article ci-dessus comprend profondément que la méthode de communication entre les threads multithreads Java est tout le contenu que je partage avec vous. J'espère que cela pourra vous donner une référence et j'espère que vous pourrez soutenir Wulin.com plus.