Wie verwende ich die Thread-Klasse, um Threads in Java zu erstellen?

Es gibt zwei Möglichkeiten, einen Thread in Java zu erstellen: die Verwendung der Thread-Klasse und die Verwendung der Runnable-Schnittstelle. Wenn Sie die Runnable-Schnittstelle verwenden, müssen Sie eine Thread-Instanz erstellen. Unabhängig davon, ob Sie einen Thread über die Thread-Klasse oder die Runnable-Schnittstelle erstellen, müssen Sie daher eine Instanz der Thread-Klasse oder ihrer Unterklasse erstellen. Der Konstruktor der Thread-Klasse wurde achtmal überladen. Der Konstruktor lautet wie folgt:

public Thread( );  public Thread(Runnable target);  public Thread(String name);  public Thread(Runnable target, String name);  public Thread(ThreadGroup group, Runnable target);  public Thread(ThreadGroup group, String name);  public Thread(ThreadGroup group, Runnable target, String name);  public Thread(ThreadGroup group, Runnable target, String name, long stackSize);

Runnable target

Eine Instanz einer Klasse, die die Runnable-Schnittstelle implementiert. Es ist zu beachten, dass die Thread-Klasse auch die Runnable-Schnittstelle implementiert. Daher können Instanzen von Klassen, die von der Thread-Klasse geerbt wurden, auch als Ziele an diesen Konstruktor übergeben werden.

String-Name

Der Name des Threads. Dieser Name kann nach dem Erstellen einer Thread-Instanz über die setName-Methode der Thread-Klasse festgelegt werden. Wenn der Thread-Name nicht festgelegt ist, verwendet der Thread den Standard-Thread-Namen: Thread-N ist die Reihenfolge, in der der Thread erstellt wird, und eine sich nicht wiederholende positive Ganzzahl.

ThreadGroup-Gruppe

Die Thread-Gruppe, zu der der aktuell erstellte Thread gehört. Wenn keine Thread-Gruppe angegeben ist, werden alle Threads einer Standard-Thread-Gruppe hinzugefügt. Details zu Thread-Gruppen werden in späteren Kapiteln ausführlich besprochen.

long stackSize

Die Größe des Thread-Stacks. Dieser Wert ist im Allgemeinen ein ganzzahliges Vielfaches der CPU-Seite. Beispielsweise beträgt die Seitengröße von x86 4 KB. Unter der x86-Plattform beträgt die Standard-Thread-Stapelgröße 12 KB.

Eine gewöhnliche Java-Klasse kann eine Thread-Klasse werden, solange sie von der Thread-Klasse erbt. Und der Thread-Code kann über die Startmethode der Thread-Klasse ausgeführt werden. Obwohl Unterklassen der Thread-Klasse direkt instanziiert werden können, muss die Ausführungsmethode der Thread-Klasse in der Unterklasse überschrieben werden, um den Thread-Code tatsächlich auszuführen. Der folgende Code gibt ein Beispiel für die Verwendung der Thread-Klasse zum Erstellen eines Threads:

package mythread;      public class Thread1 extends Thread    {        public void run()        {            System.out.println(this.getName());        }        public static void main(String[] args)        {            System.out.println(Thread.currentThread().getName());            Thread1 thread1 = new Thread1();            Thread1 thread2 = new Thread1 ();            thread1.start();            thread2.start();        }    }

Der obige Code erstellt zwei Threads: Thread1 und Thread2. Die Zeilen 005 bis 008 im obigen Code sind die Ausführungsmethode der Thread1-Klasse. Wenn die Startmethode in den Zeilen 014 und 015 aufgerufen wird, ruft das System automatisch die Ausführungsmethode auf. In Zeile 007 wird this.getName() verwendet, um den Namen des aktuellen Threads auszugeben. Da der Thread-Name beim Erstellen des Threads nicht angegeben wird, ist die Ausgabe des Thread-Namens der Standardwert des Systems, der in der Form Thread vorliegt -N. Der Threadname des Hauptthreads wird in Zeile 011 ausgegeben.

Die laufenden Ergebnisse des obigen Codes lauten wie folgt:

main
Thread-0
Thread-1

Wie aus den obigen Ausgabeergebnissen ersichtlich ist, ist die Hauptausgabe in der ***-Zeile der Name des Hauptthread. Die folgenden Thread-1 und Thread-2 sind die Ausgabeergebnisse von Thread1 bzw. Thread2.

Hinweis: Jedes Java-Programm muss einen Hauptthread haben. Im Allgemeinen lautet der Name dieses Hauptthreads main. Nur durch die Erstellung zusätzlicher Threads im Programm kann es als echtes Multithread-Programm betrachtet werden. Mit anderen Worten: Ein Multithread-Programm muss mehr als einen Thread haben.

Die Thread-Klasse verfügt über einen überladenen Konstruktor zum Festlegen des Thread-Namens. Zusätzlich zur Verwendung der Konstruktormethode zum Festlegen des Thread-Namens beim Erstellen eines Threads können Sie auch die setName-Methode der Thread-Klasse verwenden, um den Thread-Namen zu ändern. Um den Thread-Namen über den Konstruktor der Thread-Klasse festzulegen, müssen Sie den öffentlichen Thread-Konstruktor (String-Name) der Thread-Klasse in der Unterklasse von Thread verwenden. Daher müssen Sie auch einen Thread zur Übergabe in der Unterklasse von Thread hinzufügen. Namenskonstruktor. Der folgende Code gibt ein Beispiel für das Festlegen des Thread-Namens:

package mythread;   public class Thread2 extends Thread  {      private String who;       public void run()      {          System.out.println(who + ":" + this.getName());      }      public Thread2(String who)      {          super();          this.who = who;      }      public Thread2(String who, String name)      {          super(name);          this.who = who;      }      public static void main(String[] args)      {          Thread2 thread1 = new Thread2 ("thread1", "MyThread1");          Thread2 thread2 = new Thread2 ("thread2");          Thread2 thread3 = new Thread2 ("thread3");          thread2.setName("MyThread2");          thread1.start();          thread2.start();          thread3.start();      }

Es gibt zwei Konstruktoren in der Klasse:

Zeile 011: public sample2_2(String who)

Dieser Konstruktor hat einen Parameter: who. Dieser Parameter wird verwendet, um den aktuell erstellten Thread zu identifizieren. Der Standardkonstruktor von Thread, public Thread(), wird in diesem Konstruktor weiterhin aufgerufen.

Zeile 016: public sample2_2(String who, String name)

Who in diesem Konstruktor hat dieselbe Bedeutung wie Who im ersten Konstruktor, und der Name-Parameter ist der Name des Threads. In diesem Konstruktor wird der öffentliche Thread(String-Name)-Konstruktor der Thread-Klasse aufgerufen, der in Zeile 018 super(name) ist.

In der Hauptmethode werden drei Threads eingerichtet: Thread1, Thread2 und Thread3. Unter diesen legt Thread1 den Thread-Namen über die Konstruktionsmethode fest, Thread2 ändert den Thread-Namen über die SetName-Methode und Thread3 legt den Thread-Namen nicht fest.

Die laufenden Ergebnisse lauten wie folgt:

thread1:MyThread1
thread2:MyThread2
thread3:Thread-1

Wie aus den obigen Ausgabeergebnissen ersichtlich ist, wurden die Thread-Namen von Thread1 und Thread2 geändert, während der Thread Der Name von Thread3 ist immer noch der Standardwert: Thread-1. Der Grund, warum der Thread-Name von Thread3 nicht Thread-2, sondern Thread-1 lautet, liegt darin, dass der Name von Thread2 in Zeile 026 angegeben wurde. Daher wird beim Starten von Thread3 der Thread-Name von Thread3 auf Thread-1 gesetzt. Sie erhalten also die obige Ausgabe.

Hinweis: Sie können setName verwenden, um den Thread-Namen vor und nach dem Aufruf der Startmethode festzulegen. Die Verwendung von setName zum Ändern des Thread-Namens nach dem Aufruf der Startmethode führt jedoch zu Unsicherheit, was bedeutet, dass setName möglicherweise erst beim Ausführen ausgeführt wird Methode wird ausgeführt. Wenn Sie den Thread-Namen in der Ausführungsmethode verwenden möchten, tritt das Phänomen auf, dass der Thread-Name trotz Aufruf der setName-Methode nicht geändert wird.

Die Startmethode der Thread-Klasse kann nicht mehrmals aufgerufen werden. Beispielsweise kann die Methode thread1.start() nicht zweimal aufgerufen werden. Andernfalls wird eine IllegalThreadStateException ausgelöst.

Das obige ist der detaillierte Inhalt vonWie verwende ich die Thread-Klasse, um Threads in Java zu erstellen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!