Le multithreading est un point de connaissance très important à Java. Ici, l'éditeur résume le multithreading de threads Java, ce qui est très utile. J'espère que vous pourrez le maîtriser.
1. Le cycle de vie d'un fil et les cinq états de base
En ce qui concerne le cycle de vie des fils de Java, regardons d'abord la photo classique suivante:
La figure ci-dessus couvre essentiellement les points de connaissance importants du multi-threading en Java. Une fois que vous maîtrisez les points de connaissance de la figure ci-dessus, vous maîtriserez essentiellement le multi-threading en Java. Incluant principalement:
Les fils Java ont cinq États de base
Nouveau état (nouveau): Lorsqu'une paire d'objets de thread est créée, elle entre dans un nouvel état, tel que: Thread t = new Mythread ();
État prêt (runnable): lorsque la méthode start () de l'objet thread (t.start ();), le thread entre dans l'état prêt. Un thread dans l'état prêt signifie simplement que le thread est prêt et attend que le CPU planifie l'exécution à tout moment, et non pas que le thread s'exécute immédiatement après l'exécution de T.Start ();
État en cours d'exécution: Lorsque le CPU commence à planifier des threads à l'état prêt, le fil peut être vraiment exécuté, c'est-à-dire qu'il entre dans l'état en cours d'exécution. Remarque: L'état prêt est la seule entrée à l'état en cours d'exécution, c'est-à-dire que si un thread veut entrer l'état en cours d'exécution, il doit d'abord être dans l'état prêt;
État bloqué: pour une raison quelconque, un fil à l'état en cours d'exécution abandonne temporairement son utilisation du CPU et arrête l'exécution. À l'heure actuelle, il entre dans l'état de blocage. Il n'aura plus la chance d'être appelé par le processeur pour entrer dans l'état de course.
Selon les raisons du blocage, les états de blocage peuvent être divisés en trois types:
1. En attente de blocage: le thread de l'état en cours d'exécution exécute la méthode Wait () pour faire entrer le thread dans l'état de blocage d'attente;
2. Blocage synchronisé - Le fil ne parvient pas à acquérir le verrou de synchronisation synchronisé (car le verrou est occupé par d'autres threads), et il entrera dans l'état de blocage synchronisé;
3. Autre blocage - le fil entrera un état de blocage en appelant Sleep () ou join () du thread ou en émettant une demande d'E / S. Lorsque l'état de sommeil () a chronométré, join () a attendu que le fil se termine ou l'expression, ou le traitement d'E / S a été terminé, le fil est rentré à l'état prêt.
Dead: le thread a terminé l'exécution ou quitte la méthode run () en raison d'une exception, et le fil met fin à son cycle de vie.
2. Création et démarrage de Java Multithreads
Il existe trois formes de base de création de threads en Java
1. Hériter de la classe de thread et remplacer la méthode run () de la classe.
class Mythread étend Thread {private int i =; @OverRidePublic void run () {for (i =; i <; i ++) {System.out.println (thread.currentThread (). getName () + "" + i);}}} public class threadtest {public static vide main (String [] args) {for (int i =; i ++) {System.out.println (thread.currentThread (). GetName () + "" + i); if (i ==) {thread mythread = new mythread (); // Créer un nouveau thread Mythread Ce thread entre dans le nouveau fil d'état Mythread = new Mythread (); // Créer un nouveau fil Mythread Ce fil entre dans le nouvel état mythread.start (); // appelle la méthode start () pour faire entrer le thread entre l'état prêt mythread.start (); // appelle la méthode start () pour faire entrer le thread entre l'état prêt}}}} Comme indiqué ci-dessus, héritez de la classe de thread et remplacez la méthode run (), une nouvelle classe de thread Mythread est définie, où le corps de la méthode de la méthode run () représente la tâche que le thread doit effectuer, et est appelé le corps d'exécution du thread. Lors de la création de cet objet de classe de thread, un nouveau thread est créé et entre dans le nouvel état de thread. En appelant la méthode start () référencée par l'objet thread, le thread entre dans l'état prêt. À l'heure actuelle, le thread ne peut pas être exécuté immédiatement, selon le synchronisation du CPU.
2. Implémentez l'interface Runnable et remplacez la méthode run () de l'interface. La méthode run () est également un corps d'exécution de thread, créent une instance de la classe d'implémentation Runnable et utilise cette instance comme cible de la classe de threads pour créer un objet de thread. L'objet thread est l'objet de thread réel.
classe MyRunnable Implémentés Runnable {private int i =; @OverRidePublic void run () {for (i =; i <; i ++) {System.out.println (thread.currentThread (). GetName () + "" + i);}}} public class threadtest {public static main (String [String {System.out.println (thread.currentThread (). GetName () + "" + i); if (i ==) {runnable myrunnable = new myrunnable (); // Créer un objet de thread de classe d'implémentation Runnable Thread = nouveau thread (myrunnable); // utilise myrunnable comme cible de thread pour créer un nouveau thread thread thread = new Thread (myrunnable); thread.start (); // appelle la méthode start () pour faire entrer le thread entre le thread.start ();}}} Je crois que tout le monde connaît les deux façons ci-dessus de créer de nouveaux fils. Alors, quelle est la relation entre le thread et Runnable? Examinons d'abord l'exemple suivant.
classe publique threadtest {public static void main (string [] args) {for (int i =; i <; i ++) {System.out.println (thread.currentThread (). getName () + "" + i); if (i ==) {runnable myrunnable = new myrunnable (); thread thread = new MyThread (myrunnable); thread.start ();}}}} classe Myrunnable implémente Runnable {private int i =; @OverridePublic void run () {System.out.println ("dans myrunnable run"); for (i =; i <i ++) {System.out.println (Thread.CurrentShread (). "+ i);}}} class Mythread étend Thread {private int i =; public mythread (runnable runnable) {super (runnable);} @ overRidepublic void run () {System.out.println (" dans mythread run "); for (i =; i <i ++) {system.out.printLn (thread.curRentShread (). "" + i);}}} De même, il en va de même pour la création de threads qui implémentent l'interface runnable, la différence est que
Thread thread = new Mythread (myrunnable);
Cette méthode peut-elle donc créer avec succès un nouveau fil? La réponse est oui. Quant au corps d'exécution du thread à l'heure actuelle, la méthode run () est-elle dans l'interface myrunnable ou la méthode run () dans la classe Mythread? Grâce à la sortie, nous savons que le corps d'exécution du thread est la méthode run () dans la classe Mythread. En fait, la raison est très simple, car la classe de thread elle-même implémente également l'interface Runnable, et la méthode run () est d'abord définie dans l'interface Runnable.
Interface publique Runnable {public abstract void run ();} Jetons un coup d'œil à l'implémentation de la méthode run () dans l'interface Runnable dans la classe de threads:
@OverridePublic void run () {if (cible! = Null) {cible.run ();}} C'est-à-dire que lors de l'exécution de la méthode run () dans la classe de threads, la méthode run () dans la cible sera d'abord déterminée. S'il existe, la méthode run () dans la cible est exécutée, c'est-à-dire la méthode run () dans la classe qui implémente l'interface Runnable et écrase la méthode run (). Cependant, dans les colonnes ci-dessus, en raison de l'existence du polymorphisme, la méthode run () dans la classe de threads n'est pas du tout exécutée, mais le type d'exécution, c'est-à-dire que la méthode run () dans la classe Mythread est directement exécutée.
3. Créez des threads à l'aide d'interfaces appelables et futures. Plus précisément, il crée une classe d'implémentation pour l'interface appelable et implémente la méthode clall (). Et utilisez la classe FutureTask pour envelopper l'objet de classe d'implémentation callable et utilisez cet objet FutureTask comme cible de l'objet de thread pour créer un thread.
Cela semble un peu compliqué, mais il sera clair si vous regardez directement un exemple.
classe publique threadtest {public static void main (string [] args) {callable <nteger> myCallable = new myCallable (); // Créer un objet myCallable FutureTask <Integer> ft = new FutureTask <Integer> (myCallable); // utilise FutureTask pour envelopper l'objet myCallable pour (int i =; i <; i ++) {System.out.println (Thread.currentThread (). GetName () + "" + i); if (i ==) {thread thread = new Thread (ft); // L'objet FutureTask crée un nouveau thread comme cible de l'objet thread thread.start (); // thread entre dans l'état prêt}} System.out.println ("Thread principal pour l'exécution de la boucle terminée ..."); essayez {int sum = ft.get (); // obtient le résultat renvoyé par la méthode Call () dans le nouveau nouveau système de threads.out.out.println ("sum =" + sum);} catch (InterruptedException e) {e.printStackTrace ();} Catch (EXECUTIONException e) {e.printstackTrace ();}}} Class MyCallable impurable implémable <Integer> Méthode, la méthode Call () a la valeur de retour @OverRidePublic Integer Call () {int sum =; for (; i <; i ++) {System.out.println (thread.currentThread (). GetName () + "" + i); sum + = i;} Retour Sum;}} Tout d'abord, nous avons constaté qu'en implémentant l'interface appelée, la méthode run () n'est plus la méthode run (), mais la méthode Call (). Cette méthode Call () est le corps d'exécution du thread et a également une valeur de retour! Lors de la création d'un nouveau thread, l'objet myCallable est enveloppé via FutureTask et est également utilisé comme cible pour l'objet de thread. Regardez ensuite la définition de la classe Futuretask:
classe publique FutureTask <v> implémente RunnableFuture <v> {// ... Par conséquent, nous avons constaté que la classe FutureTask implémente réellement les interfaces à la fois en cours et futurs, ce qui le rend deux caractéristiques de l'avenir et de la course. Grâce à la fonction Runnable, il peut être utilisé comme cible de l'objet de thread, et la fonction future lui permet d'obtenir la valeur de retour de la méthode Call () dans le thread nouvellement créé.
Après avoir exécuté ce programme, nous constatons que SUM = 4950 est toujours la dernière sortie. "Le thread principal de la boucle a été exécuté ..." est susceptible d'être sorti au milieu de la boucle de thread enfant. À partir du mécanisme de planification du thread du processeur, nous savons qu'il n'y a aucun problème avec la synchronisation de sortie de "Le thread principal de la boucle a été exécuté ...", alors pourquoi SUM = 4950 sera-t-il pour toujours?
La raison en est que lorsque la méthode Call () du thread de l'enfant est obtenue via la méthode ft.get (), lorsque la méthode du thread de l'enfant n'a pas encore été exécutée, la méthode ft.get () bloquera jusqu'à ce que la méthode Call () soit exécutée avant l'obtention de la valeur de retour.
Ce qui précède explique principalement trois méthodes de création de threads communs. Pour le démarrage des threads, ils sont tous appelés la méthode start () de l'objet thread. Il est important de noter que la méthode start () ne peut pas être appelée deux fois sur le même objet de thread.
Iii. Statut prêt, exécuté et mort de Java Multithreading
L'état prêt est converti à l'état en cours: lorsque ce thread obtient la ressource du processeur;
L'état en cours d'exécution est converti à l'état prêt: lorsque ce thread appelle activement la méthode de rendement () ou perd des ressources de processeur pendant l'exécution.
L'état de course est converti à l'état mort: lorsque le corps d'exécution du thread est terminé ou une exception se produit.
Il convient de noter ici que lorsque la méthode de rendement () du thread est appelée, le thread passe de l'état en cours d'exécution à l'état prêt, mais le thread à l'état prêt dans le processeur est planifié a un certain aléatoire. Par conséquent, il peut se produire qu'après que le thread A appelle la méthode de rendement (), le CPU planifie toujours le thread A.
En raison des besoins réels de l'entreprise, il est souvent rencontré qu'un fil doit être résilié à une occasion spécifique de le faire entrer dans un état mort. La méthode la plus courante est actuellement de définir une variable booléenne, et lorsque les conditions sont remplies, le corps d'exécution du thread sera exécuté rapidement. comme:
classe publique threadtest {public static void main (string [] args) {myrunnable myrunnable = new myrunnable (); thread thread = new thread (myrunnable); for (int i =; i <; i ++) {System.out.printlnn (thread.currentThread (). getName () + "" + i); if (i ==) {Thread.Start ();} if (i ==) {myrunnable.stopthread ();}}}} classe Myrunnable implémente Runnable {private booléen stop; @OverRidePublic void run () {for (int i =; i <&&! stop; i ++) {system.out.printlnn (thread.currentHead (). "+ i);}} public void starthread () {this.stop = true;}}Ce qui précède est une analyse complète du thread Java Multi-Threading que l'éditeur vous a présenté. J'espère que cela vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!