Il existe deux façons d'établir des threads en Java, à savoir hériter de la classe de threads et implémenter l'interface Runnable.
Fil hérité
classe publique Mythread étend Thread {public mythread (String name) {super (name); } int i; public void run () {for (i = 0; i <5; i ++) {System.out.println (getName () + "-" + i); }} public static void main (string [] agrs) {new mythread ("thread1"). start (); new mythread ("thread2"). start (); }} / * Thread 1-0Thread 1-1thread 1-2thread 1-3thread 1-4thread 2-0thread 2-1thread 2-2thread 2-3thread 2-4 * /Comme mentionné ci-dessus, les objets de threads dans Java doivent être créés sous la forme d'une classe, et la méthode run () de la classe de base doit être remplacée dans cette classe. Cette méthode est en fait le corps d'exécution du fil. L'appel de la méthode de démarrage de cette instance de classe appelle implicitement la méthode d'exécution.
Il n'est pas difficile de voir que puisque Mythread était nouveau deux fois, les exemples des deux fois sont différents, c'est-à-dire que chacun a ses propres variables I, qui sont indépendantes les unes des autres.
Interface runnable
classe publique Myrunnable Implements Runnable {int i; public void run () {for (i = 0; i <50; i ++) {System.out.println (thread.currentThread (). getName () + "-" + i); // this.getName () ne peut pas être directement utilisé}} public static void main (String [] agrs) {myrunnable myrun = news news new myrunnable ();); nouveau thread (myrun, "thread1"). start (); nouveau thread (myrun, "thread2"). start (); } } /*Thread 1-0thread 1-1thread 2-0thread 2-3thread 2-4thread 2-5thread 2-6thread 2-7thread 2-8th thread 2-9th thread 2-10th thread 2-11th thread 2-12th thread 2-13thread 2-14th thread 2-15th thread 1-2th thread 2-16th thread 2-18th thread 2-19th thread 2-20th thread 2-21th thread 2-22th Thread 2-23th Thread 2-24th Thread 1-17th Thread 2--25 Threads 1--26 Threads 2--27 Threads 1--28 Threads 1--30 Threads 2--29 Threads 1--31 Threads 2--32 Threads 2--34 Threads 2--35 Threads 2--36 Threads 2--37 Threads 1-33 Threads 2--38 Threads 1-39 Threads 1-39 Threads 2--40 Threads 1--42 Threads 1--44 Threads 1--45 Threads 2--43 Threads 1--46 Threads 2--47 Threads 2--49 Threads 1--48 * /On peut voir que, comme cette méthode consiste à charger un objet dans la classe de threads comme cible, même s'il existe de nombreux objets de thread dans les nouveaux, tant que la cible est le même objet de référence, la méthode d'exécution de l'objet est appelée et que tous les threads partagent les ressources de l'objet cible. Par conséquent, vous verrez que le thread 1 et le thread 2 sortent un total de 51 fois, et les deux threads ont terminé la sortie de I de 0 à 49, et ne sortent pas respectivement 5 fois comme ci-dessus. Quant aux raisons pour lesquelles 51 sont sorties, les deux threads entrent à l'état prêt presque en même temps (la méthode de démarrage permet simplement au thread de saisir l'état prêt), il n'est pas difficile de constater que lorsque je suis égal à 0, le thread 1 et le thread 2 sont tous deux à l'état en cours d'exécution en même temps, ce qui entraîne un phénomène concurrentiel et la sortie de i = 0 ensemble. Après cela, le CPU change constamment de threads, de sorte qu'un seul thread est sorti en même temps.
État du fil
Les fils sont divisés en 4 états
État prêt: appelez la méthode de démarrage et entrez l'état prêt.
État en cours d'exécution: le fil à l'état prêt sera planifié par JVM et deviendra l'état de course.
État de blocage: si certaines méthodes de synchronisation ne renvoient pas les résultats, un état de blocage se produit ou le sommeil et yeild.
État de mort: le corps de la méthode est exécuté ou un fil est obligé de s'arrêter.
Opérations de base des threads
join () Merger Thread: Une fois que le thread actuel appelle la méthode de jointure d'un thread, il attendra que le thread termine l'exécution avant que le thread ne continue.
Sleep (long millisecondes) Fil Sleep: bloque le fil actuel, et il ne continuera que lorsque le temps de blocage sera écoulé. Lors du blocage à nouveau, la possession du processeur sera remise à d'autres fils, donc le sommeil (1) est souvent utilisé pour changer de threads.
** CONCESSIONNEMENTS () CONCESSIONS: ** Yeild est similaire au sommeil, mais il ne fera que des concessions à d'autres threads à un niveau supérieur ou au même niveau. Si aucun autre thread n'est inférieur à leur niveau, le thread sera à nouveau exécuté.
Fil d'arrière-plan
Une fois qu'un programme a été exécuté par le système d'exploitation, il y aura un processus et un processus a au moins un thread (thread principal). Le thread principal n'a pas beaucoup de fonctionnalités spéciales que les autres threads, simplement parce que c'est le premier thread à exécuter, d'autres threads seront créés dans le thread principal. S'il n'est pas spécifié, le thread de premier plan (y compris le thread principal) est créé par défaut. Si setDaemon (true) est appelé, le thread est explicitement défini sous forme de thread d'arrière-plan. Le fil d'arrière-plan est un fil de démon. Comme vous pouvez le voir sur le nom, sa fonction principale est de fournir des fonctions de gardien et de service pour d'autres threads. Lorsque tous les threads de premier plan se terminent, le thread d'arrière-plan sera forcé de se terminer car il n'a pas de sens à exister pour le moment.
Fil de premier plan
classe publique ForeandBackThread étend Thread {public ForeandBackThread (String Name) {super (name); } public void run () {int i; pour (i = 0; i <9999; i ++) {System.out.println (this.getName () + "-" + i); }} public static void main (String [] args) {foreandbackthread th = new ForeandBackThread ("thread a"); //th.setDaeman(True); Th.start (); Int J; pour (j = 0; j <3; j ++) {System.out.println (thread.currentThread (). getName () + "-" + j); }}}Le thread enfant complet du programme est de 0 à 9998; Cela signifie que le thread principal n'est pas spécial et que sa fin n'affectera pas le fonctionnement d'autres threads de premier plan.
Fil d'arrière-plan
classe publique ForeandBackThread étend Thread {public ForeandBackThread (String Name) {super (name); } public void run () {int i; pour (i = 0; i <9999; i ++) {System.out.println (this.getName () + "-" + i); }} public static void main (String [] args) {foreandbackthread th = new ForeandBackThread ("thread a"); Th.setDaemon (true); Th.start (); Int J; pour (j = 0; j <3; j ++) {System.out.println (thread.currentThread (). getName () + "-" + j); }}}Le programme ne peut pas sortir 0-9998 en entier et quitter, indiquant qu'après les fins du thread principal du premier plan, JVM force le thread d'arrière-plan à la fin.
Résumer
Ce qui précède concerne l'analyse des exemples de base de fils Java dans cet article, 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. Merci vos amis pour votre soutien pour ce site!