Erstellen und starten Sie einen Java-Thread

Java-Thread ist ein Objekttyp, der jedem anderen Objekt ähnelt. Ein Thread ist eine Instanz der Klasse java.lang.Thread oder eine Instanz einer Unterklasse dieser Klasse. Java-Threads sind nicht nur ein Objekttyp, sondern können auch Code ausführen.

Erstellen und Starten eines Threads

Das Erstellen eines Threads kann folgendermaßen erfolgen:

Thread thread = new Thread();

Um Um einen Java-Thread zu starten, müssen Sie die Startmethode wie folgt aufrufen:

thread.start();

Dieses Beispiel gibt keinen Code an, den der Thread ausführen wird. Dieser Thread wird sofort nach dem Start gestoppt.

Es gibt zwei Möglichkeiten anzugeben, welchen Code dieser Thread ausführen soll. Die erste Methode besteht darin, eine Unterklasse des Threads zu erstellen und dann die run()-Methode zu überschreiben. Die zweite Methode besteht darin, ein Objekt, das die Runnable-Schnittstelle implementiert, an den Thread-Konstruktor zu übergeben. Beide Methoden werden im Folgenden erwähnt.

Thread-Unterklasse

Die erste Möglichkeit besteht darin, anzugeben, welcher Code ein Thread ausführen soll, indem eine Unterklasse des Threads erstellt und diese überschrieben wird run()-Methode. Diese run()-Methode wird von diesem Thread ausgeführt, nachdem Sie die start()-Methode aufgerufen haben. Hier ist ein Beispiel:

public class MyThread extends Thread {

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

Um den obigen Thread zu erstellen und zu starten, können Sie wie folgt vorgehen:

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

Sobald der Thread gestartet ist, beginnt der Start ()-Methode Wird zurückgegeben. Es wird nicht gewartet, bis die run()-Methode endet. Diese run()-Methode wird von verschiedenen CPUs ausgeführt. Wenn diese run()-Methode ausgeführt wird, wird der Text „MyThread läuft“ ausgegeben.

Sie können auch eine anonyme Unterklasse eines Threads wie folgt erstellen:

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

  thread.start();

Das Ergebnis dieses Beispiels ist das gleiche wie oben.

Ausführbare Schnittstellenimplementierung

Die zweite Möglichkeit, anzugeben, welchen Code ein Thread ausführen soll, besteht darin, einen Thread zu erstellen, der java.lang implementiert. Ausführbare Schnittstelle einer Klasse. Dieses ausführbare Objekt kann von einem Thread ausgeführt werden.

Hier ist ein Beispiel:

public class MyRunnable implements Runnable {

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

Damit die Ausführungsmethode von einem Thread ausgeführt werden kann, müssen Sie eine MyRunnable-Instanz an den Konstruktor eines Threads übergeben. Hier ist ein Beispiel:

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

Wenn dieser Thread startet, ruft er die run-Methode von MyRunnable auf, anstatt seine eigene run-Methode auszuführen. Das obige Beispiel gibt den Text „MyRunnable läuft“ aus.

Sie können auch eine anonyme Implementierung wie folgt erstellen:

Runnable myRunnable = new Runnable(){

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

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

Thread erben oder die Schnittstelle implementieren?

Hier gibt es keine Regeln, welche der beiden Methoden die beste ist. Beide Möglichkeiten werden funktionieren. Persönlich bevorzuge ich jedoch die Implementierung der Runnable-Schnittstelle und die Verwaltung von Instanzen dieser Implementierung als Thread-Instanz. Wenn es eine Runnable-Implementierung gibt, die von einem Thread-Pool ausgeführt wird, ist es einfach, Runnable-Instanzen in die Warteschlange zu stellen, bis Threads aus dem Pool frei sind. Dies ist mit einer Thread-Unterklasse etwas schwierig zu erreichen.

Normalerweise müssen Sie nicht nur Runnable implementieren, sondern auch die Unterklasse Thread implementieren. Wenn Sie beispielsweise eine Thread-Unterklasse erstellen, können Sie mehr als ein Runnable ausführen. Dies ist ein typisches Beispiel für die Implementierung eines Thread-Pools.

Häufiger Fallstrick: Aufruf von run() statt start()

Beim Erstellen und Starten eines Threads besteht ein häufiger Fehler darin, Threads aufzurufen Die run-Methode ersetzt die start-Methode wie folgt:

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

Zuerst bemerken Sie möglicherweise nichts, da die run-Methode von Runnable auch wie erwartet ausgeführt wird. Es wird jedoch nicht von dem neuen Thread ausgeführt, den Sie erstellen. Die Ausführungsmethode des Threads, der den Thread ersetzt hat, der ihn erstellt hat, wird ausgeführt. Mit anderen Worten, der Thread, in dem die beiden oben genannten Codezeilen ausgeführt werden. Damit die Ausführungsmethode der neu erstellten Thread-Instanz aufgerufen werden kann, müssen Sie die Startmethode aufrufen.

Thread-Name

Wenn Sie einen Java-Thread erstellen, können Sie ihm einen Namen geben. Dieser Name hilft Ihnen, zwischen verschiedenen Threads zu unterscheiden. Wenn beispielsweise mehrere Threads diese Ausgabe schreiben, ist ersichtlich, welcher Thread welchen Text geschrieben hat. Hier ist ein Beispiel:

Thread thread = new Thread("New Thread") {
      public void run(){
        System.out.println("run by: " + getName());
      }
   };


   thread.start();
   System.out.println(thread.getName());

Beachten Sie das Zeichenkanalargument, das an den Thread-Konstruktor übergeben wird. Diese Zeichenfolge ist der Name des Threads. Dieser Name kann über die getName-Methode von Thread abgerufen werden. Beim Ausführen einer Runnable-Implementierung können Sie auch einen Namen übergeben. Wie folgt:

MyRunnable runnable = new MyRunnable();
   Thread thread = new Thread(runnable, "New Thread");

   thread.start();
   System.out.println(thread.getName());

Beachten Sie jedoch, dass die MyRunnable-Klasse keine Unterklasse der Thread-Klasse ist und daher nicht auf die getName()-Methode des Threads zugreifen kann, der sie ausführt.

Thread.currentThread()

Diese Methode gibt einen Verweis auf die Thread-Instanz des aktuell ausgeführten Threads zurück. Auf diese Weise können Sie auf das Thread-Objekt des Threads zugreifen, der den Codeblock ausführt. Hier ist ein Beispiel:

Thread thread = Thread.currentThread();

Sobald Sie einen Verweis auf ein Thread-Objekt haben, können Sie Methoden dafür aufrufen. Sie können beispielsweise den Namen des Threads abrufen, der ausgeführt wird:

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

Java-Thread-Instanz

这里有一个小的例子。首先它打印出来了正在执行的main方法的线程的名字。这个线程是被JVM分配的。然后启动了10个线程，以及给予他们所有作为名称（“”+i）的一个数字。每一个线程然后打印出名字，以及停止执行。

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

注意，甚至如果线程是按顺序启动的（1,2,3等等）。他们可能也不会按顺序执行的，意味着线程1可能不是第一个打印出来的名字。这个就是为什么原则上线程是并行运行而不是顺序呢执行的原因了。这个JVM以及操作系统决定着线程执行的顺序。这个顺序每次在他们启动的时候都不会相同的。
以上就是创建以及启动一个Java线程的内容，更多相关内容请关注PHP中文网（www.php.cn）！