Cet article suit l'article précédent "Explication détaillée des exemples de lecture multithreaux Java (i)".
4. L'état de blocage et le contrôle du fil des multithreads Java
Plusieurs types spécifiques de blocage Java ont été mentionnés ci-dessus. Jetons un coup d'œil aux principales méthodes qui provoquent le blocage du thread Java.
1.join ()
JOING - Laissez un thread attendre qu'un autre thread se termine avant de continuer l'exécution. Si le thread A est appelé dans la méthode join () de Thread B dans le corps d'exécution du thread, le thread A est bloqué et uniquement après que le thread B est connu pour avoir terminé l'exécution du thread B, A peut continuer à exécuter.
classe publique threadtest {public static void main (String [] args) {myrunnable myrunnable = new myrunnable (); Thread thread = nouveau thread (myrunnable); pour (int i = 0; i <100; i ++) {System.out.println (thread.currentThread (). getName () + "" + i); if (i == 30) {thread.start (); essayez {thread.join (); // Le thread principal doit attendre que le thread s'exécute avant de continuer à exécuter} catch (InterruptedException e) {e.printStackTrace (); }}}}}}}}}}}}}}}}}}}}}}}}2.Sleep ()
Sleep - Laissez le thread en cours d'exécution en pause le temps spécifié et entrez un état de blocage. Pendant la période où il dort, le fil n'aura pas l'occasion d'exécuter car il n'est pas dans l'état prêt. Même s'il n'y a pas d'autres threads exécutables dans le système à l'heure actuelle, les threads de Sleep () ne s'exécuteront pas. Par conséquent, la méthode Sleep () est souvent utilisée pour interrompre l'exécution du thread.
Comme mentionné précédemment, lorsque la méthode start () du thread nouvellement créé est appelée, le thread entre dans l'état prêt et peut obtenir la tranche de temps du CPU à un moment donné pour s'exécuter. Si vous souhaitez que le nouveau fil s'exécute immédiatement avec une certaine nécessité, appelez simplement le sommeil (1) du fil d'origine directement.
classe publique threadtest {public static void main (String [] args) {myrunnable myrunnable = new myrunnable (); Thread thread = nouveau thread (myrunnable); pour (int i = 0; i <100; i ++) {System.out.println (thread.currentThread (). getName () + "" + i); if (i == 30) {thread.start (); essayez {thread.sleep (1); // Faites en sorte que le thread soit exécuté immédiatement} catch (InterruptedException e) {e.printStackTrace (); }}}}}}}}}}}}}}}}}}}}}}}}Remarque: Dormir pendant un milliseconde suffit, car le CPU ne sera pas inactif et passera au fil nouvellement créé.
3. Fil de fond (fil de démon)
Concept / Objectif: Les threads d'arrière-plan fournissent principalement des services à d'autres threads (des threads de premier plan relativement appelés) ou des "threads de démon". Comme le fil de collecte des ordures dans le JVM.
Cycle de vie: le cycle de vie d'un fil d'arrière-plan est lié au cycle de vie du fil de premier plan. Il se reflète principalement dans: lorsque tous les threads de premier plan entrent dans l'état mort, le thread d'arrière-plan mourra automatiquement (en fait, c'est facile à comprendre, car le but du thread d'arrière-plan est de servir le fil de premier plan. Étant donné que tous les fils de premier plan sont morts, quelle est l'utilisation de la gardant toujours ... super!!).
Réglage du thread de l'arrière-plan: l'appel de la méthode setDaemon (true) de l'objet de thread peut définir le thread spécifié en tant que thread d'arrière-plan.
classe publique threadtest {public static void main (string [] args) {thread mythread = new mythread (); for (int i = 0; i <100; i ++) {System.out.println ("Thread principal i =" + i); if (i == 20) {mythread.setDaemon (true); mythread.start (); }}}}} class Mythread étend Thread {public void run () {for (int i = 0; i <100; i ++) {System.out.println ("i =" + i); essayez {thread.sleep (1); } Catch (InterruptedException e) {// TODO Block de catch généré automatiquement e.printStackTrace (); }}}}Déterminez si le thread est un thread d'arrière-plan: appelez la méthode isDeamon () de l'objet thread.
Remarque: Le thread principal est le thread de premier plan par défaut, le thread enfant créé dans la création de thread de premier plan est le thread de premier plan par défaut, et le thread créé dans le thread d'arrière-plan est le thread d'arrière-plan par défaut. Lorsque vous appelez la méthode setDeamon (true) pour définir le thread de premier plan en tant que thread d'arrière-plan, il faut l'être avant que la méthode start () ne soit appelée. Après la mort des fils la veille la veille, le JVM informe le fil d'arrière-plan à mourir, mais il faut un certain temps de recevoir les instructions à la réponse.
4. Changer la priorité des threads / setPriority ():
Chaque thread a une certaine priorité lors de l'exécution, et les threads avec une priorité élevée ont plus d'opportunités d'exécution. Chaque thread a la même priorité que le thread qui l'a créé. Le thread principal a une priorité normale par défaut.
Définir la priorité du thread: setPriority (int priorityLevel). La plage de niveaux de priorité de paramètre se situe entre 1 et 10, et les trois valeurs constantes statiques couramment utilisées sont les suivantes:
Max_priorité: 10
Min_priorité: 1
NORM_PRIORITÉ: 5
Obtenez la priorité du thread: getPriority ().
Remarque: Un objet de thread avec une priorité de thread plus élevée signifie seulement que ce thread a plus d'opportunités d'exécution, plutôt que l'exécution de la priorité.
classe publique threadtest {public static void main (string [] args) {thread mythread = new mythread (); for (int i = 0; i <100; i ++) {System.out.println ("Thread principal i =" + i); if (i == 20) {mythread.setPriority (thread.max_priority); mythread.start (); }}}}} class Mythread étend Thread {public void run () {for (int i = 0; i <100; i ++) {System.out.println ("i =" + i); }}}5. Concessions de threads: rendement ()
Le rôle de base du rendement () a été discuté dans le précédent article de blog. Dans le même temps, la méthode de rendement () est également liée à la priorité du thread. Lorsqu'un thread appelle la méthode eile () pour passer de l'état en cours d'exécution à l'état prêt, le CPU ne sélectionnera que des threads avec la même priorité ou la même priorité supérieure que le thread de la file d'attente de threads de l'état prêt à exécuter.
classe publique threadtest {public static void main (string [] args) {thread mythread1 = new mythread1 (); Thread myThread2 = new MyThread2 (); myThread1.setPriority (thread.max_priority); myThread2.setPriority (thread.min_priority); for (int i = 0; i <100; i ++) {System.out.println ("Thread principal i =" + i); if (i == 20) {mythread1.start (); mythread2.start (); Thread.yield (); }}}}} classe myThread1 étend Thread {public void run () {for (int i = 0; i <100; i ++) {System.out.println ("mythread 1 - i =" + i); }}} class MyThread2 étend Thread {public void run () {for (int i = 0; i <100; i ++) {System.out.println ("mythread 2 - i =" + i); }}}Série d'articles:
Explication des instances multipliées Java (i)
Explication détaillée des instances multipliées Java (II)
Explication détaillée des instances multipliées Java (III)