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:
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-Stack-Größ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:
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();
}
}
Die Ergebnisse der Ausführung des obigen Codes sind wie folgt:
Hinweis: Jedes Java-Programm muss einen Hauptthread haben. Im Allgemeinen lautet der Name dieses Hauptthreads main. Nur wenn andere Threads im Programm erstellt werden, 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, der den Thread-Namen festlegen kann. 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 hinzufügen, der in der Unterklasse von Thread übergeben wird. Namenskonstruktor. Der folgende Code gibt ein Beispiel für das Festlegen des Thread-Namens:
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();
}
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. Thread1 legt 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:
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 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.