So erstellen Sie einen Thread mithilfe der Thread-Klasse in Java-Threads

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);

Ausführbares Ziel

Eine Instanz einer Klasse, die implementiert die Runnable-Schnittstelle. 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-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 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ührung von Thread1 Klassenmethode. 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 der obigen Ausgabe ersichtlich ist, ist die Hauptausgabe die erste Zeile ist der Haupt-Thread-Name. 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 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 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 die öffentliche Methode der Thread-Klasse in der Unterklasse von Thread verwenden. Thread(String Daher muss der Unterklasse von Thread auch ein Konstruktor zur Übergabe des Thread-Namens hinzugefügt werden. 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();
      }

hat 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 die gleiche Bedeutung wie „who“ im ersten Konstruktor, und der Parameter „name“ ist der Name des Threadname. 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 Threadname.

Die laufenden Ergebnisse lauten wie folgt:

thread1:MyThread1
thread2:MyThread2
thread3:Thread-2

Wie aus den obigen Ausgabeergebnissen ersichtlich ist, wurden die Thread-Namen von Thread1 und Thread2 geändert, während der Thread-Name von Thread3 geändert wurde immer noch der Standardwert: Thread -2. Der Grund, warum der Thread-Name von Thread3 nicht Thread-1, sondern Thread-2 ist, liegt darin, dass Thread-1 belegt war, als Thread2 in Zeile 024 eingerichtet wurde. Daher, wenn Thread3 online eingerichtet wurde 025, der Thread von Thread3 wird auf Thread-2 gesetzt. Dann wird der Thread-Name von Thread2 in MyThread2 geändert.

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.

Das Obige ist der Inhalt der Java-Thread-Methode zur Verwendung der Thread-Klasse zum Erstellen eines Threads. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!