1. grundlegende Konzepte von Threads
Thread -Verständnis: Thread ist ein anderer Ausführungspfad in einem Programm
Jeder Zweig wird als Faden bezeichnet und Main () wird als Hauptzweig bezeichnet, auch als Hauptfaden bezeichnet.
Ein Prozess ist nur ein statisches Konzept, eine .class -Datei auf der Maschine, eine .exe -Datei auf der Maschine, die als Prozess bezeichnet wird. Der Ausführungsprozess des Programms ist wie folgt: Erstens den Code des Programms in den Codebereich des Speichers. Nachdem der Code in den Codebereich platziert wurde, wird nicht sofort ausgeführt. Dies bedeutet jedoch, dass ein Prozess bereit ist zu beginnen. Der Prozess wurde generiert, hat aber noch nicht begonnen, auszuführen. Dies ist der Prozess, daher ist der Prozess tatsächlich ein statisches Konzept und kann nicht von selbst bewegt werden. Die übliche Prozessausführung bezieht sich auf den Haupt -Thread im Prozess, der auszuführen, dh die Main () -Methode, beginnt auszuführen. Prozesse sind ein statisches Konzept, und tatsächlich werden Fäden in unseren Maschinen ausgeführt.
Das Windows-Betriebssystem unterstützt Multi-Threading. Es kann viele Threads gleichzeitig ausführen und unterstützt auch mehrere Prozesse. Daher ist das Windows-Betriebssystem ein Betriebssystem, das Multi-Threading und Multi-Processing unterstützt. Linux und Uinux sind auch Betriebssysteme, die Multi-Threading und Multi-Processing unterstützen. DOS unterstützt Multi-Threading und Multi-Processing nicht. Es unterstützt nur einzelne Prozesse. Nur ein Prozess wird zum gleichen Zeitpunkt ausgeführt, der als Single-Threading bezeichnet wird.
Ist die CPU wirklich leistungsstark und in der Lage, so viele Programme gleichzeitig auszuführen? Nein, die Ausführung der CPU lautet wie folgt: Die CPU ist sehr schnell und kann in einer Sekunde Hunderte von Millionen Male gezählt werden, sodass die CPU ihre Zeit in kleine Zeitscheiben unterteilt. Ich führe diese Zeitscheibe für eine Weile aus, das nächste Mal wird Slice eine Weile ausführen und das nächste Mal wird Slice für eine Weile andere ausführen. Obwohl es Dutzende von Threads gibt, können sie alle in sehr kurzer Zeit ausgeführt werden. Aber für uns Menschen ist die Ausführungsgeschwindigkeit der CPU zu schnell, so dass sie gleichzeitig ausgeführt wird, aber tatsächlich läuft zu einem Zeitpunkt nur ein Thread auf der CPU.
Zunächst müssen Sie drei Konzepte verstehen, wenn Sie Threads lernen :
1. Prozess: Prozess ist ein statisches Konzept
2. Thread: Es gibt einen Haupt -Thread in einem Prozess, der als Main () -Methode bezeichnet wird, bei dem es sich um ein Programm und einen anderen Ausführungspfad in einem Prozess handelt.
3. Gleichzeitig kann eine CPU nur einen Thread unterstützen, um auszuführen. Da die CPU sehr schnell läuft, sehen wir aus, als wären wir Multithreading.
Was ist wahres Multithreading? Wenn Ihre Maschine Dual-CPUs oder Dual Cores hat, ist sie in der Tat Multi-Threaded.
2. Erstellung und Start von Threads
In Java werden Java -Threads über die Klasse java.lang.thread implementiert, und jedes Thread -Objekt repräsentiert einen neuen Thread. Es gibt zwei Möglichkeiten, einen neuen Thread zu erstellen: Die erste besteht darin, aus der Thread -Klasse zu erben, und das andere ist die Implementierung der Schnittstelle. Wenn das VM beginnt, wird ein Thread durch die Hauptmethode (öffentliche statische void main ()) definiert, und dieser Thread wird als Hauptfaden bezeichnet. Neue Threads können erstellt werden, indem Thread -Instanzen erstellt werden. Sie müssen nur ein Thread -Objekt ein neues Thread -Objekt benötigen, und es wird ein neuer Thread angezeigt. Jeder Thread vervollständigt seinen Betrieb über die Methode run (), die einem bestimmten Thread -Objekt entspricht. Die Methode run () wird als Fadenkörper bezeichnet.
Beispiel 1: Erstellen und starten Sie einen neuen Thread mit der Implementierung der Runnable -Schnittstelle
Erstellen Sie einen neuen Thread, um die Auslaufmethode aufzurufen
Paket cn.galc.test; public class testthread1 {public static void main (String args []) {runner1 r1 = new Runner1 (); // Hier wird ein neues Objekt der Thread -Klasse herausgestellt // r1.run (); // Dies wird als Methodenanruf bezeichnet. Die Ausführung des Methodenaufrufs besteht darin, zu warten, bis die Run () -Methode ausgeführt wird, bevor die Main () -Methode weiterhin ausgeführt wird. Thread t = neuer Thread (R1); // Um einen neuen Thread zu starten, müssen Sie ein neues Thread -Objekt herauskommen // Thread (Runnable -Ziel) wird hier verwendet. Der Konstruktor t.start (); // Starten Sie den neu geöffneten Thread, der neue Thread führt die Run () -Methode aus, und der neue Thread und der Haupt -Thread werden parallel für (int i = 0; i <10; i ++) {System.out.println ("minteod:"+i) ausgeführt. }}}/*Definieren Sie eine Klasse, um die Runnable -Schnittstelle zu implementieren. Implementieren der Runnable -Schnittstelle bedeutet, dass diese Klasse eine Thread -Klasse ist. }}}Der Ausführungsprozess von Multi-Thread-Programmen lautet wie folgt:
Rufen Sie die Ausführenmethode direkt an, ohne einen neuen Thread zu öffnen
Die Betriebsergebnisse sind wie folgt:
Beispiel 2: Erben Sie die Thread -Klasse und überschreiben Sie die Run () -Methode, um einen neuen Thread zu erstellen und zu starten
Paket cn.galc.test;/*Die zweite Methode zur Erstellung und Start von Threads: Definieren Sie eine Unterklasse des Threads und implementieren Sie die Run () -Methode*/public class testthread2 {public static void main (String args []) {Runner2 R2 = New Runner2 (); r2.Start (); // rufen Sie die Start () -Methode auf, um den neu geöffneten Thread für (int i = 0; i <= 10; i ++) {System.out.println ("MainMethod:"+i) zu starten. }}}/*Runner2 -Klasse erbt aus der Thread -Klasse, indem Sie ein Objekt der Runner2 -Klasse instanziieren, können Sie einen neuen Thread öffnen. Rufen Sie die aus der Thread -Klasse geerbte Start () -Methode. Sie können den neu geöffneten Thread starten*/class Runner2 erweitert Thread {public void run () {// Schreiben Sie die Implementierung der Run () -Methode für (int i = 0; i <= 10; i ++) {System.out.println ("Runner2:"+i); }}}Die Auswahl der Verwendung von zwei Methoden zum Erstellen neuer Threads, nämlich die Implementierung der Runnable -Schnittstelle und das Erben der Thread -Klasse, sollte beim Öffnen eines neuen Threads Priorität haben. Da die Implementierung einer Schnittstelle mehrfach implementiert werden kann, kann die Vererbung einer Klasse nur eine einzige Vererbung sein. Wenn Sie beim Öffnen eines neuen Threads die Runnable -Schnittstelle verwenden können, versuchen Sie daher, die Vererbung aus der Thread -Klasse nicht zu verwenden, um neue Threads zu öffnen.
3. Übergang des Thread -Zustands
3.1. Grundlegende Methoden zur Threadsteuerung
3.2. Einführung in die Schlaf-/Join-/Ertragsmethode
Beispiel für die Anwendung der Schlafmethode:
Paket cn.galc.test; import java.util.*; public class testthread3 {public static void main (String args []) {MyThread thread = new mythead (); Thread.Start (); // rufen Sie die Start () -Methode auf, um den neu geöffneten Thread zu starten. Sleep () -Methode ist eine statische Methode, die in der Thread -Klasse deklariert ist, sodass Sie das Format von Thread.Sleep () verwenden können, um */* mythread.sleep(10000) zu rufen; Die MyThread -Klasse erbt die Thread -Klasse und erbt natürlich auch die Sleep () -Methode, sodass Sie sie auch mit dem Format von MyThread.sleep () *// *aufrufen können. System.out.println ("Der Hauptfaden schläft 10 Sekunden lang und startet wieder"); // Wenn Sie die statische Methode einer anderen Klasse in der Main () -Methode aufrufen, müssen Sie den Namen "Class.static Methode" verwenden, wobei sich die statische Methode befindet "Methode zum Aufrufen /* also hier soll der Hauptfaden für 10 Sekunden schlafen lassen. Welcher Thread nennt die Sleep () -Methode, so dass der Hauptfaden nun schläft. */} catch (interruptedException e) {e.printstacktrace (); } //thread.interrupt();/use interrupt () Methode zur Beendigung der Ausführung eines Thread -Threads.flag = false; // Die Schleifenbedingungen ändere und die tote Schleife/** * Wenn eine InterruptedException auftritt, setzen Dies ist ein besserer Weg, um den untergeordneten Thread zu beenden* / / *** Aufruf in Interrupt (), um den Lauffaden zu brechen, entspricht dem Gießen eines Topfes kaltes Wasser auf den Hauptfaden und das Brechen des ausführenden Sub-Threads. Nach dem unterbrochenen Unterthread wird eine InterruptedException geworfen, die die Return-Anweisung ausführt und die Ausführung des Threads beendet. Das Sub-Thread beendet also die Ausführung des Threads nach 10 Sekunden Ausführung */}} Klasse Mythead erweitert Thread {boolean Flag = true; // ein Tag definieren, um die Bedingungen der Schleife öffentlicher void Run () {/ * Hinweis zu steuern: Hier können Sie keine Ausnahme direkt hinter der Run () -Methode zum Ausdruck bringen. können unterschiedliche Ausnahmen können als die umgeschriebene Methode. * Also können Sie nur versuchen, versuchen Sie ... catch (), um Ausnahmen zu fangen*/ while (flag) { System.out.println("======================================================================================================== =================================================================== =================================================================== =================================================================== =================================================================== =================================================================== =================================================================== Natürlich ist es nicht falsch, es mit dem Format von "Klassenname" zu nennen "*/ // Mythead.sleep (1000); // Verwenden Sie das Format des" Klassennamens ". Jede Sekunde in einer toten Schleife, und die aktuelle Systemzeit wird jede Sekunde ausgedruckt} catch (InterruptedException E) { /** Beim Schlafen kann eine Tafel mit kaltem Wasser den Schlaf unterbrechen.Auslaufergebnisse:
Beispiel für die Join -Methode:
Paket cn.galc.test; public class testthread4 {public static void main (String args []) {MyThread2 Thread2 = new MyThread2 ("mythead"); // While creating a new thread object, name the thread object mythread thread2.start();// Start thread try { thread2.join();// Call the join() method to merge the thread, merge the child thread mythread into the main thread// After merging the thread, the execution process of the program is equivalent to the execution process of the method call} catch (InterruptedException e) { e.printStackTrace(); } für (int i = 0; i <= 5; i ++) {System.out.println ("Ich bin Hauptthread"); }}} class mythread2 erweitert Thread {MyThread2 (String S) {Super (s); / * * Verwenden Sie das Super -Schlüsselwort, um den Konstruktor der übergeordneten Klasse zu nennen GetName ()); // Verwenden Sie // Public Final String getName (), das im übergeordneten Klassen -Thread definiert ist, gibt den Namen dieses Threads zurück. Versuchen Sie es mit {Schlaf (1000); // Machen Sie den Kinderfaden für 1 Sekunde jedes Mal, wenn es ausgeführt wird, catch (InterruptedException e) {return; }}}}Auslaufergebnisse:
Beispiel für die Verwendung der Ertragsmethode:
Paket cn.galc.test; public class testthread5 {public static void main (String args []) {mythread3 t1 = new mythread3 ("t1"); /* Zwei untergeordnete Threads T1 und T2 wurden gleichzeitig geöffnet. T1 und T2 führen beide die Run () -Methode aus*//*Es gibt insgesamt 3 Threads parallel während der Ausführung dieses Programms, nämlich untergeordnete Threads T1 und T2 und den Haupt -Thread*/ mythread3 T2 = new MyThread3 ("T2"); t1.start (); // Starter Child Thread t1 t2.start (); // Starter Child Thread T2 für (int i = 0; i <= 5; i ++) {System.out.println ("Ich bin Hauptthread"); }}} class mythread3 erweitert Thread {myThread3 (string s) {super (s); } public void run () {für (int i = 1; i <= 5; i ++) {System.out.println (getName () + ":" + i); Wenn (i % 2 == 0) {rendite (); // Wenn die Ausführung durch 2 geteilt werden kann, kann der aktuelle Thread ausgeführt werden, und ein anderer Thread, der die Run () -Methode ausführt, werden zuerst ausgeführt/ * * * Sie können während des Ausführens des Programms sehen. (i%2 == 0) Mal gibt es den Thread zum T1 -Thread zur Prioritätsausführung */}}} ausDie Betriebsergebnisse sind wie folgt:
Das obige ist der gesamte Inhalt dieses Artikels. Wir hoffen, es kann Ihnen helfen.