Detaillierte Erläuterung der drei Möglichkeiten zur Implementierung von Multithreading in Java

Die Beispiele in diesem Artikel zeigen drei Möglichkeiten zur Implementierung von Multithreading in Java als Referenz. Der spezifische Inhalt ist wie folgt:

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
 
public class Main {
 
  public static void main(String[] args) {
    //方法一：继承Thread
    int i = 0;
//    for(; i < 100; i++){
//      System.out.println(Thread.currentThread().getName() + " " + i);
//      if (i == 5) {
//        ThreadExtendsThread threadExtendsThread = new ThreadExtendsThread();
//        threadExtendsThread.start();
//      }
//    }
     
    //方法二：实现Runnable
//    for(i = 0; i < 100; i++){
//      System.out.println(Thread.currentThread().getName() + " " + i);
//      if (i == 5) {
//        Runnable runnable = new ThreadImplementsRunnable();
//        new Thread(runnable).start();
//        new Thread(runnable).start();
//      }
//    }
 
    //方法三：实现Callable接口
    Callable<Integer> callable = new ThreadImplementsCallable();
    FutureTask<Integer> futureTask = new FutureTask<>(callable);
    for(i = 0; i < 100; i++){
      System.out.println(Thread.currentThread().getName() + " " + i);
      if (i == 5) {
        new Thread(futureTask).start();
        new Thread(futureTask).start();
      }
    }
    try {
      System.out.println("futureTask ruturn: " + futureTask.get());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
 
}

Methode 1, geerbt von Thread

public class ThreadExtendsThread extends Thread {
  private int i;
  @Override
  public void run() {
    for(; i < 100; i++) {
      System.out.println(getName() + " " + i); 
    }
  }
}

run Die Methode ist der Thread-Ausführungskörper und das ThreadExtendsThread-Objekt ist das Thread-Objekt.

Methode 2, implementieren Sie die Runnable-Schnittstelle

public class ThreadImplementsRunnable implements Runnable {
  private int i;
  @Override
  public void run() {
    for(; i < 100; i++){
      System.out.println(Thread.currentThread().getName() + " " + i);
    }
  }
}

Die Run-Methode ist der Thread-Ausführungskörper. Bei Verwendung wird ein Thread-Objekt verwendet und das Runnable-Objekt an den Thread übergeben Objekt als Ziel. Und dasselbe Runnable-Objekt kann als Ziel mehrerer Threads verwendet werden, und diese Threads teilen sich alle die Instanzvariablen des Runnable-Objekts.

Methode drei, implementieren Sie die Callable-Schnittstelle

import java.util.concurrent.Callable;
 
public class ThreadImplementsCallable implements Callable<Integer> {
  private int i;
   
  @Override
  public Integer call() throws Exception {
    for(; i < 100; i++){
      System.out.println(Thread.currentThread().getName() + " " + i);
    }
    return i;
  }
}

Die Callable-Schnittstelle ähnelt der Runnable-Schnittstelle, ist jedoch leistungsfähiger als die andere. Der Thread-Ausführungskörper ist die Call-Methode einen Rückgabewert und kann Ausnahmen auslösen. Wenn es verwendet wird, binden Sie das Callable-Objekt in ein FutureTask-Objekt ein und geben Sie den Rückgabewerttyp über Generics an. Sie können die get-Methode von FutureTask später aufrufen, um das Ausführungsergebnis abzurufen.

Das Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, er wird für das Studium aller hilfreich sein.

Ausführlichere Erläuterungen zu den drei Möglichkeiten zur Implementierung von Multithreading in Java und verwandte Artikel finden Sie auf der chinesischen PHP-Website!