J'ai brièvement introduit l'utilisation du multi-threading java. J'ai déjà introduit la classe de threads et la classe Runnable. Afin de mieux comprendre le multi-threading, cet article effectue une analyse détaillée du thread.
commencer()
Jetons d'abord un œil à l'introduction de cette méthode dans l'API:
Fait que le thread commence à s'exécuter; La machine virtuelle Java appelle la méthode d'exécution du thread.
Le résultat est que deux fils fonctionnent simultanément; le thread actuel (renvoyé de l'appel à la méthode de démarrage) et l'autre thread (exécutant sa méthode d'exécution).
Il est illégal de démarrer plusieurs fois un fil. Surtout lorsque le thread a terminé l'exécution, il ne peut pas être redémarré.
Utilisez la méthode de démarrage pour démarrer le thread, ce qui réalise vraiment le multi-threading. Pour le moment, vous n'avez pas besoin d'attendre que le code corporel de la méthode d'exécution termine l'exécution et de continuer à exécuter directement le code suivant. Un thread est démarré en appelant la méthode start () de la classe de threads. À l'heure actuelle, le fil est dans un état prêt (à l'exécution) et n'est pas en cours d'exécution. Une fois la tranche de temps CPU obtenue, la méthode run () commence à être exécutée. Ici, la méthode run () est appelée le corps du fil. Il contient le contenu du fil à exécuter. La méthode d'exécution se termine et le thread se termine immédiatement.
La méthode de démarrage est une méthode pour démarrer le thread. Après l'avoir utilisé, Java créera un nouveau thread pour exécuter la méthode dans Run. Voici une petite démo:
pour (int i = 0; i <3; i ++) {thread t = new Thread (new Runnable () {@Override public void run () {System.out.println (thread.currentThread (). getName () + "start"); try {thread.sleep (1000);} catch (interruptedException e) {e. System.out.println (thread.currentThread (). GetName () + "end");}}); t.start (); } System.out.println ("Il est fini"); Résultats de l'exécution:
c'est fini
Démarrage du thread-1
Thread-0 Démarrer
Thread-2 Start
Fike-0 fin
File-1 Fin
Fin de thread-2
Étant donné que le multithreading est aléatoire, les résultats peuvent être différents à chaque fois, ce à quoi nous devons également faire attention. L'ordre d'exécution et l'ordre d'appel des threads ne sont pas cohérents.
courir()
La méthode d'exécution consiste à appeler la méthode d'exécution de Runnable Set by Thread et à modifier la démo ci-dessus:
pour (int i = 0; i <3; i ++) {thread t = new Thread (new Runnable () {@Override public void run () {System.out.println (thread.currentThread (). getName () + "start"); try {thread.sleep (1000);} catch (interruptedException e) {e. System.out.println (thread.currentThread (). GetName () + "end");}}); t.run (); } System.out.println ("Il est fini"); Résultats de l'exécution:
Démarrage principal
fin principale
Démarrage principal
fin principale
Démarrage principal
fin principale
c'est fini
Le résultat direct de la méthode d'exécution est très différent du début. Il est exécuté dans l'ordre et n'ouvre pas un nouveau fil.
arrêt()
La méthode d'arrêt consiste à forcer l'arrêt de l'exécution du thread. Ce n'est pas sûr, alors n'utilisez pas cette méthode. Lorsque l'arrêt est appelé, les ressources verrouillées seront publiées, mais cette version est incohérente et peut facilement causer des problèmes de programme. Si vous souhaitez contrôler l'arrêt du thread, vous pouvez utiliser des variables personnalisées pour juger ou Isterrupted () Méthode:
Class Thread1 étend Thread {@Override public void run () {// juger si le corps du thread est en cours d'exécution pendant (! isInterrupted ()) {// faire quelque chose}}} interrompre()
La fonction de l'interruption consiste à informer le thread que vous avez été interrompu, mais l'exécution d'interruption spécifique nécessite un traitement personnalisé du thread, et vous pouvez même l'ignorer et continuer l'exécution. La solitude spécifique consiste à lancer une exception interrompue lors de l'exécution de filetage des méthodes de jointure, d'attente et de sommeil.
Thread t1 = nouveau thread (new Runnable () {@Override public void run () {System.out.println (thread.currentThread (). GetName () + "start"); try {for (int i = 0; i <100000; i ++) {System.out.out.println (i + ""); System.out.println ("Le thread est interrompu"); // Vous pouvez faire une version de ressources, la journalisation, etc. E.PrintStackTrace ();} System.out.println (Thread.CurrentThread (). GetName () + "end"); t1.start (); Thread.Sleep (100); t1.interrupt ();Résultats de l'exécution:
65666768 Le fil est interrompujava.lang.InterruptedException: Sleep InterruptedThread-0 End sur java.lang.thread.sleep (méthode native) à com.wk.aqi.act.test $.
isInterrupted ()
Pour déterminer si le thread est interrompu, après avoir exécuté la méthode d'interruption ci-dessus, il renverra vrai.
setPriority (int newpriority) et getPriority ()
Définissez la priorité des threads et obtenez la priorité des threads. Les ressources allouées par le CPU sont axées sur les threads avec des priorités plus élevées.
Thread t1 = new thread (new Runnable () {@Override public void run () {long t = system.currentTimemillis (); System.out.println (thread.currentThread (). GetName () + "start"); for (int i = 0; i <1000; i ++) {try {thread. Bloc de capture généré par Auto E.PrintStackTrace ();}} System.out.println (Thread.CurrentThread (). GetName () + "T1 end" + (System.CurrentTimeMeLis () - T)); Thread t2 = new thread (new Runnable () {@Override public void run () {long t = system.currentTimemillis (); system.out.println (thread.currentThread (). GetName () + "start"); for (int i = 0; i <1000; i ++) {try {thread.sleep (1);} capture (interrupt {to three.sleep (1);} capture (interrupt {to three.sleep (1);} capture (interrupt. Bloc de capture généré par Auto E.PrintStackTrace ();}} System.out.println (Thread.CurrentThread (). GetName () + "T2 end" + (System.CurrentTimeMeLis () - T)); t1.setPriority (10); T2.SetPriority (1); t2.start (); t1.start ();Résultats de l'exécution:
Thread-0 startThread-1 startThread-0 T1 end 1357thread-1 t2 end 1371
Lorsque la priorité est la même, T1 et T2 sont terminés presque en même temps, et il existe des différences évidentes lorsque la priorité est différente.
getName ()
C'est relativement simple, obtenez le nom du fil.
rejoindre () et rejoindre (long millis)
La fonction de la méthode Jion consiste à attendre que l'exécution du thread se termine et que jointer (long millis) peut définir le temps d'attente maximal. Par exemple, le thread principal doit attendre que le thread enfant se termine et obtenir le résultat du thread enfant avant de continuer à s'exécuter. Pour le moment, vous pouvez utiliser la méthode de jointure.
Thread T1 = new Thread (new Runnable () {@Override public void run () {long t = System.currenttimemillis (); System.out.println (thread.currentThread (). GetName () + "start"); try {Thread.Sleep (1000);} Catch Block (interruptedException e) {// TODO Auto-generated Catch Block. } System.out.println (Thread.currentThread (). GetName () + "T1 end" + (System.CurrentTimeMillis () - T));}}); t1.start (); t1.join (); System.out.println ("En attente de l'exécution de T1 avant l'exécution");Résultats de l'exécution:
Thread-0 startThread-0 T1 end 1001 attendez que T1 soit exécuté avant l'exécution
Résumer
Ce qui précède est toute l'explication détaillée du code de la méthode d'implémentation du fil multithread Java, j'espère que cela sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler.