Explication détaillée des fils Java et la différence entre les fils et les processus
1. Processus et threads
Chaque processus a un espace mémoire unique et une application peut démarrer plusieurs processus en même temps. Par exemple, dans IE Browser, l'ouverture d'un navigateur IE équivaut à démarrer un processus.
Un thread fait référence à un processus d'exécution dans un processus et un processus peut contenir plusieurs threads.
Chaque processus a besoin du système d'exploitation pour y attribuer un espace mémoire indépendant, et plusieurs threads dans le même processus partagent cet espace, c'est-à-dire la mémoire partagée et d'autres ressources.
Chaque fois que Java.exe est appelé, le système d'exploitation démarrera un processus de machine virtuelle Java. Lorsque le processus de machine virtuelle Java est démarré, la machine virtuelle Java créera un thread principal, qui commencera à s'exécuter à partir de la méthode principale de l'entrée du programme.
Chaque fois qu'une machine virtuelle Java démarre un thread, il affectera une pile de méthode de thread au thread pour stocker des informations pertinentes (telles que les variables locales, etc.), et le thread s'exécute sur cette pile. Par conséquent, les variables locales dans les objets Java sont en file d'attente, mais les variables d'instance et les variables de classe ne sont pas stockées dans la pile, elles ne sont donc pas des filets.
Il y a trois états du processus: prêt, exécution et blocage.
2. Méthode de création de threads
Méthode Runnable: (Cette méthode est flexible, recommandée)
classe publique Thread02 implémente Runnable {public static void main (String [] args) {runnable r = new <strong> thread02 </strong> (); Thread t1 = nouveau thread (<strong> r </strong>, "t1"); / ** * Code source de thread * Thread public (Runnable Target, String Name) {init (null, cible, nom, 0); } * / Thread t2 = nouveau thread (r, "t2"); t1.start (); // Démarrer le thread T1, à l'état prêt, en attente de CPU t2.Start (); // Démarrer le thread T2, à l'état prêt, en attente de CPU t1.run (); // Le thread principal principal appelle la méthode d'exécution de l'objet t1} public void run () {System.out.println ("Le nom du thread est" + thread.currentThread (). GetName ()); }}Le résultat de l'opération peut être:
Le nom du thread est le nom de T1Thread est le nom de Mainthread est T2
La tête de la tête
classe publique Thread03 étend Thread {public static void main (String [] args) {thread03 t1 = new <strong> thread03 </strong> (); // l'écrivez-le en tant que thread t1 = new Thread () Remarque: Thread03 est un thread à ce moment t1.start (); } public void run () {System.out.println ("Le nom du thread est" + thread.currentThread (). getName ()); }}Résultat en cours d'exécution: Le nom du thread est Thread-0
Remarque: En plus des threads personnalisés, il existe également un fil principal chaque fois que le programme s'exécute.
complet:
classe publique thread01 {public static void main (String [] args) {thread thread = new Thread (); thread.start (); // Ce qui fonctionne vraiment est exécuté () / ** et exécuter dans thread * public void run () {if (cible! = null) {Target.run (); }} Ainsi, le thread que vous avez créé vous-même doit réécrire la méthode d'exécution et mettre le contenu à exécuter dans run (), vous devez donc implémenter l'interface ou l'héritage, puis générer des sous-classes * // comment créer du thread 1 thread subclass méthode (héritage) thread thread1 = new thread () {public void run () {while (true) {try {thread.sleep (500); (InterruptedException e) {e.printStackTrace (); } //Thread.currentThread () obtient le thread actuel System.out.println ("Le nom de Thread 1 est" + thread.currentThread (). GetName ()); }}}}; // thread1.start (); // Impossible de démarrer sans écrire le thread // comment créer une méthode de thread 2 Runnable (implémentation) Il est recommandé d'utiliser Thread Thread2 = new Thread (new Runnable () {public void run () {while (true) {try {Thread.Sleep (300);} capture (interruptedException e) {e.printStackTrace ();} System.out.out.PrintLn ("Thread2'name est "+ Thread.currentThread (). GetName ());}}}); // thread2.start (); // Exécuter le thread nouveau thread (new Runnable () {public void run () {System.out.println ("runnable" + thread.currentThread (). getName ());}}) {public void run () {// La méthode d'exécution dans la sous-claire remplace la méthode d'exécution dans la classe parent, de sorte que le fil de filetage ne sera pas exécuté System.out.out.out.out. "+ Thread.currentThread (). GetName ()); } }.commencer(); } / *** * L'exécution du multithreading dans un seul CPU est très susceptible de réduire l'efficacité de l'exécution plutôt que d'améliorer une personne faisant la même chose à différents endroits * /}Merci d'avoir lu, j'espère que cela peut vous aider. Merci pour votre soutien à ce site!