Es gibt zwei Möglichkeiten, Threads in Java zu erstellen: mit der Thread-Klasse und mit 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:
Kopieren Sie den Codecode wie folgt:
öffentlicher Thread( );
öffentlicher Thread (ausführbares Ziel);
öffentlicher Thread(String-Name);
öffentlicher Thread(Ausführbares Ziel, String-Name);
public Thread(ThreadGroup-Gruppe, ausführbares Ziel);
public Thread(ThreadGroup-Gruppe, String-Name);
public Thread(ThreadGroup-Gruppe, ausführbares Ziel, String-Name);
public Thread(ThreadGroup-Gruppe, ausführbares Ziel, String-Name, lange StackSize);
Lauffähiges Ziel
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.
Stringname
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.
lange Stapelgröße
Die Größe des Thread-Stacks 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 zeigt ein Beispiel für die Verwendung der Thread-Klasse zum Erstellen eines Threads:
Kopieren Sie den Codecode wie folgt:
Paket mythread;
Die öffentliche Klasse Thread1 erweitert Thread
{
public void run()
{
System.out.println(this.getName());
}
public static void main(String[] args)
{
System.out.println(Thread.currentThread().getName());
Thread1 Thread1 = neuer Thread1();
Thread1 Thread2 = neuer Thread1 ();
thread1.start();
thread2.start();
}
}
Der obige Code erstellt zwei Threads: Thread1 und Thread2. Die Zeilen 005 bis 005 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 Ergebnisse der Ausführung des obigen Codes sind wie folgt:
hauptsächlich
Thread-0
Thread-1
Wie aus der obigen Ausgabe ersichtlich ist, ist die Hauptausgabe in der ersten Zeile der Name des Hauptthreads. 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-Unterklasse verwenden. Daher müssen Sie auch einen Thread zur Übergabe im Thread-Namenskonstruktor hinzufügen . Der folgende Code gibt ein Beispiel für das Festlegen des Thread-Namens:
Kopieren Sie den Codecode wie folgt:
Paket mythread;
Die öffentliche Klasse Thread2 erweitert Thread
{
privater String who;
public void run()
{
System.out.println(who + ":" + this.getName());
}
öffentlicher Thread2(String who)
{
super();
this.who = wer;
}
public Thread2(String who, String name)
{
super(Name);
this.who = wer;
}
public static void main(String[] args)
{
Thread2 thread1 = neuer Thread2 ("thread1", "MyThread1");
Thread2 thread2 = neuer Thread2 ("thread2");
Thread2 thread3 = neuer 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)
„Wer“ in diesem Konstruktor hat dieselbe Bedeutung wie „Wer“ im ersten Konstruktor, und der Parameter „Name“ ist der Name des Threads. In diesem Konstruktor wird der öffentliche Thread-Konstruktor (String-Name) 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 Laufergebnisse sind wie folgt:
Kopieren Sie den Codecode wie folgt:
thread1:MyThread1
thread2:MyThread2
thread3:Thread-1
Wie aus der obigen Ausgabe ersichtlich ist, wurden die Thread-Namen von Thread1 und Thread2 geändert, während der Thread-Name von Thread3 immer noch der Standardwert ist: 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 ausgeführt wird, wenn die Ausführungsmethode ausgeführt wird hingerichtet. 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.