L'état du fil
Diagramme d'état du thread:
illustrer:
Les fils comprennent les 5 états suivants.
1. Nouvel état : une fois l'objet de thread créé, il entre dans le nouvel état. Par exemple, thread thread = new Thread ().
2. Runnable: également connu sous le nom de "État exécutable". Une fois l'objet thread créé, d'autres threads appellent la méthode start () de l'objet pour démarrer le thread. Par exemple, thread.start (). Un fil dans un état prêt peut être prévu pour s'exécuter par le CPU à tout moment.
3. État d'exécution: le thread obtient des autorisations CPU pour l'exécution. Il convient de noter que les threads ne peuvent entrer que l'état en cours d'exécution à partir de l'état prêt.
4. État bloqué: l'état bloqué signifie que le fil abandonne les droits d'utilisation du CPU pour une raison quelconque et cesse temporairement de fonctionner. Ce n'est que lorsque le fil entre dans l'état prêt qu'il a une chance d'aller à l'état de course. Il existe trois types de blocage:
(1) En attendant de bloquer - en appelant la méthode Wait () du thread, laissez le fil d'attente pour l'achèvement d'un certain travail.
(2) Blocage synchronisé - Un fil ne parvient pas à acquérir un verrou de synchronisation synchronisé (car le verrou est occupé par d'autres threads), il entrera dans un é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.
5. État mort: le thread a fini d'exécuter ou de quitter la méthode run () en raison d'une exception, et le fil met fin à son cycle de vie.
Le contenu impliqué dans ces 5 états comprend la classe d'objets, le thread et les mots clés synchronisés. Nous apprendrons ces contenus un par un dans les chapitres suivants.
Classe d'objets, définit les fonctions de sommeil / réveil telles que Wait (), Notify (), notifyall (), etc.
La classe de thread définit certaines fonctions de fonctionnement du thread de colonne. Par exemple, Sleep () Sleep Fonction, Interrupt () Fonction Interrupt, getName () Obtenez le nom du thread, etc.
Synchronisé est un mot-clé; Il se distingue par des blocs de code synchronisés et des méthodes synchronisées. La fonction de synchronisée est de permettre aux threads d'acquérir le verrou de synchronisation de l'objet.
Lorsque nous introduisons Wait (), Notify () et d'autres méthodes en détail plus tard, nous analyserons pourquoi "attendre (), notifier () et d'autres méthodes devraient être définies dans la classe d'objets, pas la classe de threads."
Deux façons d'implémenter le multi-threading: thread et runnable
Runnable est une interface qui ne contient qu'une méthode run (). Sa définition est la suivante:
Interface publique Runnable {public abstract void run ();} Le rôle de Runnable, implémente le multi-lancement. Nous pouvons définir une classe A pour implémenter l'interface Runnable; Créez ensuite un nouveau thread via un nouveau thread (nouveau A ()) et d'autres méthodes.
Le thread est une classe. Le thread lui-même implémente l'interface runnable. Sa déclaration est la suivante:
Le thread de classe publique implémente Runnable {}
Le rôle du thread est de réaliser le multi-threading.
Similitudes et différences entre le thread et le runnable:
La similitude entre le thread et le runnable: les deux sont des «méthodes de mise en œuvre multipliées».
Les différences entre le thread et le runnable:
Le thread est une classe et Runnable est une interface; Le thread lui-même est une classe qui implémente l'interface Runnable. Nous savons que "une classe ne peut avoir qu'une classe parent, mais elle peut implémenter plusieurs interfaces", donc Runnable a une meilleure évolutivité.
De plus, Runnable peut également être utilisé pour le «partage des ressources». Autrement dit, plusieurs threads sont créés sur la base d'un certain objet Runnable, et ils partageront des ressources sur l'objet Runnable.
Généralement, il est recommandé d'implémenter le multi-threading via "Runnable"!
Exemples multithreading pour le thread et Runnable
1. Exemple de fil multithre
Ci-dessous, nous pouvons mieux comprendre le thread et passer à travers des exemples, et dessiner sur un exemple en ligne plus convaincant. // Code source threadtest.java
class Mythread étend Thread {private int ticket = 10; public void run () {for (int i = 0; i <20; i ++) {if (this.ticket> 0) {System.out.println (this.getName () + "ticket: ticket" + this.ticket--); }}}}}}; public class threadtest {public static void main (string [] args) {// start 3 threads t1, t2, t3; Chaque fil vend 10 billets! Mythread t1 = new mythread (); Mythread t2 = new mythread (); Mythread t3 = new mythread (); t1.start (); t2.start (); t3.start (); }} Résultats en cours:
Thread-0 Vente de billets: Ticket10Thread-1 Vente de tickets: Ticket10Thread-2 Vente de tickets: Ticket10Thread-1 Vente de tickets: Ticket9Thread-0 Vente de tickets: Ticket9Thread-1 Sells: Ticket8Thread-2 Secket Venture: Ticket9Thread-1 Vente de ticked: Tickread-1 Ticket Venture: Ticket-2 Vente de billets: ticket7Thread-1 Vente de tickets: ticket3Thread-0 Billets: Ticket6Thread-1 Billets: Ticket2Thread-2 Billets: Ticket6Thread-2 Billets: Ticket5Thread-2 Billets: Ticket4THREAD-1 TICKETS: TICKET1RED-0 Billets: Ticket2Thread-0 Billets: Ticket1Thread-0 Billets: Ticket2Thread-0 Billets: Ticket1
Description des résultats:
(1) Mythread hérite de Thread, qui est un fil personnalisé. Chaque mythread vend 10 billets.
(2) Le thread principal principal crée et démarre 3 fils d'enfants Mythread. Chaque fil d'enfant vend 10 billets.
2. Exemple multithread de runnable
Ensuite, nous modifions le programme ci-dessus. Implémentez une interface via Runnable, implémentant ainsi le multi-threading.
// runnableTest.java CODE SOURCE CLASSE Mythread implémente Runnable {private int ticket = 10; public void run () {for (int i = 0; i <20; i ++) {if (this.ticket> 0) {System.out.println (thread.currentThread (). getName () + "Ticket Sell: Ticket" + this.ticket--); }}}}}; classe publique RunNableTest {public static void main (String [] args) {mythread mt = new mythread (); // Démarrer 3 threads T1, T2, T3 (ils partagent un objet coulable), et ces 3 threads vendent un total de 10 billets! Thread t1 = nouveau thread (mt); Thread t2 = nouveau thread (mt); Thread t3 = nouveau thread (mt); t1.start (); t2.start (); t3.start (); }} Résultats en cours:
Thread-0 Vente de billets: ticket10THREAD-2 STRECTION DE TICKET: TICKET8THREAD-1 VENDRE DE TICKET: TICKET9THREAD-2 Vente de billets: Ticket6Thread-0 Vente de tickets: Ticket7Thread-2 Sells: Ticket4Thread-1 Sell: Ticket5Thread-2 Sell: Ticket2Thread-0 TICKET VENDRE: TICKET3D-1-1 TIBLE VENTE: TICKET1
Description des résultats:
(1) Contrairement à ce qui précède "Mythread hérite de Thread"; Ici, Mythread implémente l'interface thread.
(2) Le thread principal principal crée et démarre 3 threads enfants, et ces 3 threads enfants sont tous créés en fonction de "MT, objet Runnable". Le résultat de l'opération est que ces 3 fils d'enfants ont vendu un total de 10 billets. Cela signifie qu'ils partagent l'interface Mythread.