Methoden zum Erstellen und Ausführen von Java-Threads

Die Java-Thread-Klasse ist auch eine Objektklasse und ihre Instanzen erben alle von java.lang.Thread oder seinen Unterklassen. Sie können einen Thread in Java folgendermaßen erstellen:

Tread thread = new Thread();

Um den Thread auszuführen, können Sie die start()-Methode des Threads aufrufen:

thread.start();

Im obigen Beispiel haben wir keinen laufenden Code für den Thread geschrieben, daher wurde der Thread nach dem Aufruf dieser Methode beendet.

Es gibt zwei Möglichkeiten, Code zu schreiben, der 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 darin, die Runnable-Schnittstelle beim Erstellen zu implementieren Klasse. 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 run-Methode. Die run-Methode ruft die start()-Methode auf anschließend ausgeführt werden. Ein Beispiel lautet wie folgt:

public class MyThread extends Thread {  public void run(){    System.out.println("MyThread running");  }}

Sie können die obige Thread-Unterklasse auf folgende Weise erstellen und ausführen

MyThread myThread = new MyThread();myTread.start();

Sobald der Thread gestartet ist, kehrt die Startmethode sofort ohne zurück Warten auf die Ausführungsmethode. Rückkehr erst nach Abschluss der Ausführung. Es ist, als ob die Ausführungsmethode auf einer anderen CPU ausgeführt würde. Wenn die run-Methode ausgeführt wird, wird die Zeichenfolge „MyThread running“ ausgegeben.

Sie können auch wie folgt eine anonyme Unterklasse von Thread erstellen:

Thread thread = new Thread(){  public void run(){    System.out.println("Thread Running");  }};thread.start();

Wenn die Ausführungsmethode des neuen Threads ausgeführt wird, gibt der Computer die Zeichenfolge „Thread Running“ aus.

Implementieren Sie die Runnable-Schnittstelle

Die zweite Möglichkeit, Thread-Ausführungscode zu schreiben, besteht darin, eine neue Instanz einer Klasse zu erstellen, die die java.lang.Runnable-Schnittstelle implementiert von Threads aufgerufen. Nachfolgend finden Sie ein Beispiel:

public class MyRunnable implements Runnable {  public void run(){   System.out.println("MyRunnable running");  }}

Damit der Thread die run()-Methode ausführen kann, muss das Instanzobjekt von MyRunnable im Konstruktor der Thread-Klasse übergeben werden. Ein Beispiel lautet wie folgt:

Thread thread = new Thread(new MyRunnable());thread.start();

Wenn der Thread ausgeführt wird, ruft er die Ausführungsmethode auf, die die Runnable-Schnittstelle implementiert. Im obigen Beispiel wird „MyRunnable läuft“ ausgegeben.

Ähnlich können Sie auch 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 thread = new Thread(myRunnable);thread.start();

Eine Unterklasse erstellen oder die Runnable-Schnittstelle implementieren?

Es gibt keine eindeutige Antwort, welche der beiden Methoden besser ist, beide erfüllen die Anforderungen. Meiner persönlichen Meinung nach bevorzuge ich die Implementierung der Runnable-Schnittstelle. Da der Thread-Pool Threads, die die Runnable-Schnittstelle implementieren, effektiv verwalten kann, werden bei vollem Thread-Pool neue Threads zur Ausführung in die Warteschlange gestellt, bis der Thread-Pool frei ist. Wenn Threads durch die Implementierung einer Thread-Unterklasse implementiert werden, wird dies komplizierter.

Manchmal müssen wir die beiden Möglichkeiten zur gleichzeitigen Implementierung der Runnable-Schnittstelle und der Thread-Unterklasse kombinieren. Beispielsweise kann eine Instanz, die eine Thread-Unterklasse implementiert, mehrere Threads ausführen, die die Runnable-Schnittstelle implementieren. Eine typische Anwendung ist der Thread-Pool.

Häufiger Fehler: Aufruf der run()-Methode anstelle der start()-Methode

Ein häufiger Fehler beim Erstellen und Ausführen eines Threads ist der Aufruf der run()-Methode des Threads anstelle der start( )-Methode, wie unten gezeigt:

Thread newThread = new Thread(MyRunnable());newThread.run();  //should be start();

Zuerst werden Sie nichts Falsches spüren, da die run()-Methode tatsächlich wie erwartet aufgerufen wird. Tatsächlich wird die run()-Methode jedoch nicht vom gerade erstellten neuen Thread ausgeführt, sondern vom aktuellen Thread, der den neuen Thread erstellt hat. Das heißt, es wird von dem Thread ausgeführt, der die beiden oben genannten Codezeilen ausführt. Wenn Sie möchten, dass der erstellte neue Thread die Methode run() ausführt, müssen Sie die Startmethode des neuen Threads aufrufen.

Thread-Name

Beim Erstellen eines Threads können Sie dem Thread einen Namen geben. Es hilft uns, zwischen verschiedenen Threads zu unterscheiden. Beispiel: Wenn mehrere Threads in System.out schreiben, können wir anhand des Thread-Namens leicht herausfinden, welcher Thread ausgibt. Ein Beispiel lautet wie folgt:

MyRunnable runnable = new MyRunnable();Thread thread = new Thread(runnable, "New Thread");thread.start();System.out.println(thread.getName());

Da MyRunnable keine Unterklasse von Thread ist, ist zu beachten, dass die MyRunnable-Klasse keine getName()-Methode hat. Sie können die Referenz des aktuellen Threads auf folgende Weise abrufen:

Thread.currentThread();

Daher können Sie den Namen des aktuellen Threads über den folgenden Code abrufen:

String threadName = Thread.currentThread().getName();

Thread-Code Beispiel:
Hier ist ein kleines Beispiel. Geben Sie zunächst den Namen des Threads aus, der die Methode main() ausführt. Dieser Thread wird von der JVM zugewiesen. Starten Sie dann 10 Threads und nennen Sie sie 1–10. Jeder Thread wird beendet, nachdem er seinen eigenen Namen ausgegeben hat.

public class ThreadExample { public static void main(String[] args){    System.out.println(Thread.currentThread().getName());     for(int i=0; i<10; i++){        new Thread("" + i){           public void run(){            System.out.println("Thread: " + getName() + "running");           }        }.start();     } }}

Es ist zu beachten, dass die Reihenfolge der Startthreads zwar ordnungsgemäß, die Ausführungsreihenfolge jedoch nicht ordnungsgemäß ist. Mit anderen Worten: Thread Nr. 1 ist nicht unbedingt der erste Thread, der seinen Namen an die Konsole ausgibt. Dies liegt daran, dass Threads parallel und nicht sequentiell ausgeführt werden. Die JVM und das Betriebssystem bestimmen die Ausführungsreihenfolge von Threads und sie stimmt nicht unbedingt mit der Startreihenfolge von Threads überein.

Verwandte Empfehlungen:

Ein einfaches Codebeispiel für einen Thread-sicheren Java-Zähler

Instanzanalyse der Synchronisation und Asynchronität von Objekten in Java Threads

warten/benachrichtigen auf Kommunikation zwischen Java-Threads

Das obige ist der detaillierte Inhalt vonMethoden zum Erstellen und Ausführen von Java-Threads. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!