Die Java -Thread -Klasse ist auch eine Objektklasse, und ihre Instanzen werden von java.lang.thread oder seiner Unterklasse geerbt. Sie können auf folgende Weise einen Thread in Java erstellen. Das Ausführen des Threads kann die Start () -Methode des Threads aufrufen:
Profil Thread = neuer Thread ();
Thread.Start ();
Im obigen Beispiel haben wir keinen laufenden Code für den Thread geschrieben, so dass der Thread nach dem Aufrufen der Methode endet.
Es gibt zwei Möglichkeiten zum Schreiben von Code, das ausgeführt wird, wenn ein Thread ausgeführt wird: Eine besteht darin, eine Instanz der Thread -Unterklasse zu erstellen und die Ausführungsmethode zu überschreiben, und die zweite besteht darin, die Runnable -Schnittstelle beim Erstellen der Klasse zu implementieren. Als nächstes erklären wir diese beiden Methoden im Detail:
Erstellen Sie eine Unterklasse von Thread
Erstellen Sie eine Instanz der Thread -Unterklasse und überschreiben Sie die Auslaufmethode. Die Auslaufmethode wird nach dem Aufrufen der Start () -Methode ausgeführt. Das Beispiel der obigen Thread -Unterklasse kann erstellt und folgendermaßen ausgeführt werden:
öffentliche Klasse MyThread erweitert Thread {public void run () {System.out.println ("MyThead Running"); }} MyThread myThread = new MyThread (); myTread.start ();Sobald der Thread gestartet wurde, kehrt die Startmethode sofort zurück und wartet erst, bis die Auslaufmethode vor der Rückkehr ausgeführt wird. Es ist, als würde die Run -Methode auf einer anderen CPU ausgeführt. Wenn die Run -Methode ausgeführt wird, wird das String -MyThread ausgeführt.
Sie können auch eine anonyme Unterklasse von Thread erstellen wie folgt:
Thread thread = new Thread () {public void run () {System.out.println ("Thread Running"); }}; Thread.Start ();Wenn die Auslaufmethode des neuen Threads ausgeführt wird, druckt der Computer den Zeichenfolge "Thread Laufen" aus.
Implementierung der Runnable -Schnittstelle
Der zweite Weg, Thread Execution Code zu schreiben, besteht darin, eine neue Instanz der Klasse zu erstellen, die die Schnittstelle java.lang.runnable implementiert, und die Methoden in der Instanz können vom Thread aufgerufen werden. Das Folgende ist ein Beispiel:
public class myrunnable implements runnable {public void run () {System.out.println ("Myrunnable Running"); }}Damit Threads die Run () -Methode ausführen können, muss das Instanzobjekt von Myrunnable in den Konstruktor der Thread -Klasse übergeben. Beispiele sind wie folgt:
Thread = neuer Thread (neuer Myrunnable ());
Thread.Start ();
Wenn der Thread ausgeführt wird, wird die Run -Methode aufgerufen, die die Runnable -Schnittstelle implementiert. "Myrunnable Running" wird im obigen Beispiel gedruckt.
In ähnlicher Weise können Sie eine anonyme Klasse erstellen, die die Runnable -Schnittstelle implementiert, wie unten gezeigt:
Runnable Myrunnable = new Runnable () {public void run () {System.out.println ("Runnable Running"); }} Thread = neuer Thread (Myrunnable); Thread.Start ();Erstellen Sie eine Unterklasse oder implementieren Sie eine runnable Schnittstelle?
Es gibt keine eindeutige Antwort darauf, welche dieser beiden Methoden besser sind, und sie können die Anforderungen erfüllen. Meiner persönlichen Meinung nach implementieren ich es vor, die Runnable -Schnittstellenmethode zu implementieren. Da der Thread -Pool Threads effektiv verwalten kann, die die Runnable -Schnittstelle implementieren. Wenn der Thread -Pool voll ist, stehen neue Threads für die Ausführung nach oben, bis der Thread -Pool im Leerlauf ist. Und wenn der Thread durch die Implementierung der Thread -Unterklasse implementiert wird, wird dies etwas komplizierter sein.
Manchmal müssen wir die beiden Möglichkeiten zur gleichzeitigen Implementierung der Runnable -Schnittstelle und der Subklasse von Threads integrieren. Eine Instanz, die eine Thread -Unterklasse implementiert, kann beispielsweise mehrere Threads ausführen, die die Runnable -Schnittstelle implementieren. Eine typische Anwendung ist Thread Pool.
Häufiger Fehler: Aufrufen der Methode run () anstelle der Start () -Methode
Ein häufiger Fehler beim Erstellen und Ausführen eines Threads besteht darin, die Methode Run () des Threads anstelle der Start () -Methode aufzurufen, wie unten gezeigt:
Thread newThread = neuer Thread (Myrunnable ());
newThread.run (); // sollte start () sein;
Zuerst fühlen Sie nichts falsch, denn die Run () -Methode wird in der Tat so genannt, wie Sie es wünschen. Tatsächlich wird die Run () -Methode jedoch nicht durch den gerade erstellten neuen Thread ausgeführt, sondern von dem aktuellen Thread ausgeführt, der den neuen Thread erstellt hat. Das heißt, es wird von dem Thread ausgeführt, der die beiden oben genannten Codezeilen ausführt. Um den erstellten neuen Thread die Run () -Methode auszuführen, muss die Startmethode des neuen Threads aufgerufen werden.
Threadname
Beim Erstellen eines Threads können Sie dem Thread einen Namen geben. Es hilft uns, verschiedene Threads zu unterscheiden. Zum Beispiel: Wenn mehrere Threads in System geschrieben werden. Beispiele sind wie folgt:
Myrunnable Runnable = new Myrunnable (); Thread Thread = neuer Thread (runnable, "neuer Thread"); Thread.start (); System.out.println (Thread.getName ());
Es sollte beachtet werden, dass die Myrunnable -Klasse keine GetName () -Methode hat, weil Myrunnable keine Thread -Unterklasse ist. Sie können auf folgende Weise einen Verweis auf den aktuellen Thread erhalten:
Thread.currentThread ();
String threadName = thread.currentThread (). GetName ();
Beispiel -Threadcode:
Hier ist ein kleines Beispiel. Aus den Threadnamen der Main () -Methode ausgeben. Dieser Thread wird vom JVM zugewiesen. Öffnen Sie dann 10 Threads und nennen Sie sie 1 ~ 10. Jeder Thread beendet sich, nachdem er seinen eigenen Namen ausgegeben hat.
public class threadExample {public static void main (String [] args) {System.out.println (Thread.currentThread (). getName ()); für (int i = 0; i <10; i ++) {neuer Thread ("" + i) {public void run () {System.out.println ("Thread:" + getName () + "running"); } }.Start(); }}}Es ist zu beachten, dass zwar die Reihenfolge der Startfäden bestellt wird, die Ausführungsreihenfolge nicht bestellt wird. Das heißt, Thread 1 ist nicht unbedingt der erste Thread, der seinen Namen an die Konsole ausgibt. Dies liegt daran, dass Threads eher parallel als nacheinander ausgeführt werden. JVM und das Betriebssystem bestimmen die Ausführungsreihenfolge von Threads, und die Startreihenfolge ist nicht unbedingt das gleiche wie die von Threads.
Das obige ist eine Zusammenstellung der von Java -Threads erstellten Informationen. Wir werden in Zukunft weiterhin relevante Informationen hinzufügen. Vielen Dank für Ihre Unterstützung für diese Website!