Cet article explique plus en détail la technologie de threading de Java avec des exemples. Je pense qu'il sera utile pour une compréhension approfondie de la programmation Java. Les détails sont les suivants :
De nombreuses personnes ont une certaine compréhension des threads lorsqu'elles apprennent JAVA, et lorsque nous avons commencé à contacter le développement Android, nous avons vraiment découvert à quel point les threads sont importants. Cet article partagera avec vous l'expérience de l'utilisation des threads Java pour votre référence.
Tout d’abord, tout le monde doit comprendre que les threads et les processus ne sont pas la même chose. Qu’est-ce qu’un processus ? Le processus est exactement comme nous devons exécuter le fichier de classe, et le thread est ce qui appelle réellement les ressources CPU à exécuter. Un fichier de classe ne comporte généralement qu'un seul processus, mais il peut y avoir plusieurs threads. L'exécution de threads est une méthode d'exécution asynchrone.
1. Comment démarrer un autre thread dans la fonction principale :
L'exemple de code est le suivant :
public class Thread_one { public static void main(String [] args){ Run run = new Run(); //run.run();//Ceci est un appel de méthode, qui est très différent d'un thread Thread thread = new Thread (run); thread.start();//Démarrez le thread et appelez la méthode run() du thread for(int i=1; i<=20; i++){ System.out.println("La valeur de main thread i : --------"+i); } }}class Run implémente Runnable{ @Override public void run() { for(int i=1; i<=20; i++){ System.out .println( "La valeur du sous-thread i : "+i);2. La méthode sleep dans les threads
L'exemple de code est le suivant :
public class Thread_sleep { /* * Thread pause*/ public static void main(String [] args){ Runone run = new Runone(); Thread thread = new Thread(run.start(); (5000); thread.interrupt();//Interrompre l'exécution du thread//thread.stop();//Par rapport à l'interruption du thread, l'arrêt est trop brutal et n'est pas recommandé. le thread enfant doit être forcé à se fermer. } catch (InterruptedException e) { e.printStackTrace(); } }}class Runone implémente Runnable{ @Override public void run() { for(int i=1; i<10; i++ ){ try { Thread.sleep(1000 ); System.out.println("-----"+new Date()+"-----" } catch (InterruptedException e) { return ;// Lorsqu'il est détecté que le thread enfant est interrompu, fermez le thread enfant directement} } }}Une remarque spéciale ici est que thread.interrupt(); peut interrompre l'exécution d'un thread. C'est un peu plus doux que stop, mais ce n'est pas la meilleure façon de fermer un thread. Voici une méthode pour vous :
public class Thread_stop { public static void main(String [] args){ Runtrois run = new Runtwo(); Thread th = new Thread(run); try { Thread.sleep(5000); InterruptedException e) { e.printStackTrace(); } run.setStop(); }}class Runtrois implémente Runnable{ boolean flag; @Override public void run() { flag = int i = 0; { System.out.println("fil enfant----"+(i++)); Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } public void setStop(){ drapeau = faux ; } }Permettez-moi de vous présenter brièvement la fusion et l'attribution dans les discussions :
1. Comment fusionner les fils , La méthode join() est appelée ici
L'exemple de code est le suivant :
public class Thread_join { /* * Fusionner les threads*/ public static void main(String [] args){ Runtwo run = new Runtwo(); Thread thread = new Thread(run); ();//Fusionner les threads, cela équivaut à un appel de méthode} catch (InterruptedException e) { e.printStackTrace(); } for(int i=0; i<10; i++){ System.out.println("main Sujet : "+i); } }}class Runtwo implémente Runnable{ @Override public void run() { for(int i=0; i<10; i++){ System.out.println("Fil enfant : --- -"+i); } } }2. Comment abandonner le thread .La méthode rendement() de Thread est appelée ici, comme indiqué ci-dessous :
public class Thread_yield { /**Abandonnez le processeur * @param args */ public static void main(String[] args) { Th th = new Th("aaa"); for(int i = 0); ; i<=10; i++){ System.out.println("Thème principal----"+i); } }}classe Th extends Thread{ Th(){} Th(String s){super(s) ;} @Override public void run() { for(int i = 0; i<=10; i++){ if(i%3!=0){ System.out.println("fil enfant"+i }); else{ System.out.println("Sub-thread i="+i+" threadswitches"); rendement();//Cette méthode ne peut être utilisée que si vous héritez de Thread} } }}Enfin, je voudrais partager avec vous la question de la priorité des threads . Le code est le suivant :
public class Thread_priority { /* * priorité définit la priorité du thread * La priorité par défaut du Thread est 5 ; la priorité maximale du Thread est 10 et la priorité minimale est 0 */ public static void main(String [] args){ T1 t1 = new T1(); T2 t2 = new T2(); //t1.setPriority(Thread.NORM_PRIORITY+3); //Définir la priorité de t1 t2.start(); extends Thread { @Override public void run() { for(int i = 0; i<50; i++){ System.out.println("Thread T1-----"+i } }}class T2 extends Sujet{ @Override public void run() { for(int i = 0; i<50; i++){ System.out.println("Thread T2"+i } } }Je pense que vous avez essentiellement compris le mécanisme de threading en JAVA grâce au code ci-dessus. J'espère que ce que décrit cet article vous sera utile dans votre étude approfondie de la programmation Java.