1. Le concept de thread: Thread fait référence au flux d'exécution d'une tâche du début à la fin. Le thread fournit un mécanisme pour exécuter des tâches. Pour Java, plusieurs threads peuvent être exécutés simultanément dans un programme, et ces threads peuvent s'exécuter simultanément sur un système multiprocesseur. Lorsque le programme s'exécute en tant qu'application, l'interpréteur Java démarre un thread pour la méthode Main ().
2. Parallèle et concurrence:
(1) Concurrence: dans un système de processeur unique, plusieurs threads partagent le temps du processeur et le système d'exploitation est responsable de la planification et de l'allocation de ressources.
(2) Parallélisme: Dans un système multiprocesseur, plusieurs processeurs peuvent exécuter plusieurs threads en même temps. Ces fils peuvent fonctionner simultanément en même temps. Contrairement à la concurrence, seuls plusieurs threads peuvent partager le temps CPU et un seul thread peut fonctionner en même temps.
3. Création de fils:
(1) Concept de base: chaque tâche de Java est un objet exécutable. Pour créer une tâche, la classe de tâches doit d'abord être définie et la classe de tâches doit implémenter l'interface Runnable. Et les threads sont essentiellement des objets qui conviennent à l'exécution des tâches. Le processus d'exécution d'un thread est l'exécution de la méthode run () dans une classe de tâches jusqu'à la fin.
(2) Créer des threads via l'interface Runnable:
un. Définissez une classe de tâches pour implémenter l'interface Runnable, implémenter la méthode run () dans l'interface Runnable (la méthode run () indique au thread système comment exécuter) et définir le code de tâche ou la logique de traitement spécifique dans la méthode run ().
né Après avoir défini la classe de tâches, créez un objet de tâche pour la classe de tâches.
c. La tâche doit être exécutée dans un thread, créer un objet de la classe de bande de roulement et passer l'objet de classe de tâche créé plus tôt qui implémente l'interface Runnable au constructeur de la classe de carton en tant que paramètre.
d. Appelez la méthode start () de l'objet de classe de bande de roulement et démarrez un thread. Il entraîne l'exécution de la méthode Run () de la tâche. Lorsque la méthode run () est exécutée, le thread se terminera.
Exemple de code:
package com.muzeet.mutithread; // Chaque tâche est une instance de l'interface exécutable. La tâche est un objet géré et le thread est un objet qui facilite l'exécution de la tâche. Vous devez créer une classe de tâches et remplacer la méthode d'exécution pour définir la classe publique tâche ThreadDemo1 implémente Runnable {private int Countdown = 10; @Override // Réécrivez la méthode d'exécution et définissez la tâche publique void run () {while (Countdown--> 0) {System.out.println ("$" + thread.currentThread (). GetName () + "(" + Countdown + ")"); }} // L'appel de la méthode de démarrage commencera un thread, ce qui entraînera l'appel de la méthode d'exécution dans la tâche. Une fois la méthode d'exécution exécutée, le thread termine public static void main (String [] args) {runnable Demo1 = new ThreadDemo1 (); Thread Thread1 = nouveau thread (Demo1); Thread Thread2 = nouveau thread (Demo1); thread1.start (); thread2.start (); System.out.println ("Rocket Launch Countdown:"); }}Résultats du programme en cours d'exécution:
Rocket Launch Countdown: $ thread-0 (9) $ thread-0 (8) $ thread-0 (7) $ thread-0 (6) $ thread-0 (5) $ thread-0 (4) $ thread-0 (3) $ thread-0 (2) $ thread-0 (1) $ thread-0 (0)
Exécutez deux objets de tâche en même temps:
public static void main (String [] args) {runnable Demo1 = new ThreadDemo1 (); Runnable Demo2 = new ThreadDemo1 (); Thread Thread1 = nouveau thread (Demo1); Thread Thread2 = nouveau thread (Demo2); thread1.start (); thread2.start (); System.out.println ("Rocket Launch Countdown:"); }Résultats en cours:
Compte à rebours du lancement de fusées: $ Thread-0 (9) $ thread-0 (8) $ thread-0 (7) $ thread-0 (6) $ thread-1 (9) $ thread-0 (5) $ thread-1 (8) $ thread-0 (4) $ thread-1 (7) $ thread-0 (3) $ Thread-1 (6) $ thread-1 (5) $ thread-0 (2) $ thread-1 (4) $ thread-1 (3) $ thread-1 (2) $ thread-1 (1) $ thread-1 (0) $ thread-0 (1) $ thread-0 (0)
(3) Hériter de la classe de threads pour créer un thread:
un. Créer d'abord une classe de tâches étend la classe de threads. Étant donné que la classe de thread implémente l'interface Runnable, la classe de tâches personnalisée implémente également l'interface Runnable et la méthode RERUN (), qui définit le code de tâche ou la logique de traitement spécifique.
né Créez un objet de classe de tâche, qui peut utiliser du thread ou Runnable comme type de variable personnalisé.
c. Appelez la méthode start () de l'objet personnalisé et démarrez un thread.
Exemple de code:
package com.muzeet.mutithread; // Chaque tâche est une instance de l'interface exécutable. La tâche est un objet exécutable et le thread peut exécuter l'objet. La classe de tâches doit être créée et la méthode d'exécution doit être remplacée pour définir la tâche Classe publique ExtendFromthread étend Thread {private int Countdown = 10; @Override // Réécrivez la méthode d'exécution et définissez la tâche publique void run () {while (Countdown--> 0) {System.out.println ("$" + this.getName () + "(" + Countdown + ")"); }} // L'appel de la méthode de démarrage commencera un thread, ce qui entraînera l'appel de la méthode d'exécution dans la tâche. Une fois la méthode d'exécution exécutée, le thread termine public static void main (String [] args) {extendFromThread Thread1 = new ExtendFromThread (); ExtendFromThread Thread2 = new ExtendFromThread (); thread1.start (); thread2.start (); System.out.println ("Rocket Launch Countdown:"); }}Résultats en cours:
Compte à rebours du lancement de fusées: $ Thread-0 (9) $ thread-0 (8) $ thread-0 (7) $ thread-0 (6) $ thread-0 (5) $ thread-0 (4) $ thread-0 (3) $ thread-0 (2) $ thread-0 (1) $ thread-0 (0) $ Thread-1 (9) $ thread-1 (8) $ thread-1 (7) $ thread-1 (6) $ thread-1 (5) $ thread-1 (4) $ thread-1 (3) $ thread-1 (2) $ thread-1 (1) $ thread-1 (0)
Un thread attend qu'un autre thread se termine avant l'exécution: lors de l'exécution de la tâche Printnum, lors de l'impression du numéro 50, il se tourne pour exécuter la tâche d'impression du caractère C, et continue alors d'exécuter la tâche d'impression du numéro après l'exécution du thread4 du thread4.
package com.muzeet.testThread; public class printnum implémente runnable {private int lastnum; public printnum (int n) {LastNum = n; } @Override public void run () {// TODO Méthode générée automatique Thread Thread4 = nouveau thread (new printharch ('c', 40)); thread4.start (); essayez {pour (int i = 1; i <= lastnum; i ++) {System.out.println ("" + i); if (i == 50) {thread4.join (); }}} catch (InterruptedException e) {// TODO Block de catch généré automatiquement e.printStackTrace (); }}}4. Comparaison des deux méthodes (réimprimées)
Tout d'abord, nous analysons les résultats de sortie des deux méthodes. Nous créons également deux threads. Pourquoi les résultats sont-ils différents?
En utilisant l'interface Runnable pour créer des threads, vous pouvez partager le même objet cible (TreadDemo1tt = NewTreadDemo1 ();), implémentant plusieurs threads identiques pour traiter la même ressource. Lorsque le premier thread termine la tâche, le compte à rebours est déjà 0, donc le deuxième thread ne sortira pas. Héritage de la méthode de création de threads par thread, deux objets de classe de tâches sont créés, avec leurs variables de membre respectives, et ils ne s'interfèrent pas entre eux.
Ensuite, regardez une explication de JDK:
L'interface Runnable doit être implémentée par des classes qui ont l'intention d'exécuter leurs instances via un certain thread. La classe doit définir une méthode sans paramètre appelée run.
Le but de la conception de cette interface est de fournir un protocole public pour les objets qui souhaitent exécuter du code lorsqu'ils sont actifs. Par exemple, la classe de thread implémente Runnable. L'activation signifie qu'un fil a été démarré et ne s'est pas encore arrêté.
De plus, Runnable fournit une méthode d'activation pour les classes qui ne sont pas des sous-classes de thread. En instanciant une instance de fil et en se prenant comme la cible en cours d'exécution, vous pouvez exécuter une classe qui implémente Runnable. Dans la plupart des cas, si vous souhaitez simplement remplacer la méthode run () et ne pas remplacer d'autres méthodes de thread, vous devez utiliser l'interface Runnable. Ceci est important car à moins que le programmeur ait l'intention de modifier ou d'améliorer le comportement de base d'une classe, une sous-classe ne doit pas être créée pour cette classe. (Il est recommandé d'utiliser la création d'une classe de tâches et l'implémentation de l'interface Runnable au lieu de hériter de la classe de threads)
Adopter l'héritage de la classe de threads:
(1) Avantages: facile à écrire. Si vous devez accéder au thread actuel, vous n'avez pas besoin d'utiliser la méthode thread.currentThread (). Vous pouvez obtenir le thread actuel directement en utilisant cela.
(2) Inconvénients: parce que la classe de thread a hérité de la classe de threads, il ne peut pas hériter d'autres classes parentales.
Utilisation de la méthode d'interface Runnable:
(1) Avantages: les classes de threads implémentent uniquement l'interface gérée et peuvent également hériter d'autres classes. De cette façon, plusieurs threads peuvent partager le même objet cible, il est donc très adapté à plusieurs threads identiques pour gérer la même ressource, de sorte que le code et les données CPU peuvent être séparés pour former un modèle clair, ce qui reflète mieux l'idée orientée objet.
(2) Inconvénients: la programmation est un peu compliquée. Si vous devez accéder au thread actuel, vous devez utiliser la méthode thread.currentThread ().
Résumer
Ce qui précède est tout au sujet des deux façons de créer des threads dans les exemples de lecture multithre et de code comparatifs Java. J'espère que ce sera utile à tout le monde. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!