Wie viele Möglichkeiten gibt es, um in Java einen neuen Thread zu erstellen?

Question

Eigentlich, welche anderen Möglichkeiten gibt es neben dem Erweitern der Thread-Klasse und der Implementierung des Runnable-Interfaces?

Answer 1

Es gibt genau eine Möglichkeit, einen neuen Thread in Java zu erstellen, und das ist, eine Instanz von java.lang.Thread zu instantiieren (um diesen Thread tatsächlich auszuführen, müssen Sie auch start() aufrufen).

Alles andere, was Threads in Java-Code erstellt, greift hinter dem Deckmantel auf diese eine Methode zurück (z.B. wird eine Implementierung einer ThreadFactory zu einem bestimmten Zeitpunkt Thread-Objekte instanzieren, ...).

Es gibt zwei verschiedene Möglichkeiten, anzugeben, welcher Code ausgeführt werden soll in dem Thread:

• Implementieren Sie das Interface java.lang.Runnable und übergeben Sie eine Instanz der Klasse, die es implementiert, an den Thread-Konstruktor.
• Erweitern Sie Thread selbst und überschreiben Sie seine run()-Methode.

Der erste Ansatz (Implementierung von Runnable) wird normalerweise als der korrektere Ansatz angesehen, weil Sie normalerweise keinen neuen "Typ" von Thread erstellen, sondern einfach nur etwas Code (d.h. ein Runnable) in einem dedizierten Thread ausführen möchten.

Answer 2

Threads können hauptsächlich auf 3 verschiedene Arten erstellt werden

1. Erweitern Sie die java.lang.Thread-Klasse

   class SampleThread extends Thread {

   // Methode, in der die Thread-Ausführung beginnt
   public void run(){
       // Logik, die in einem Thread ausgeführt werden soll
   }
   
   // Schauen wir uns an, wie man Threads startet
   public static void main(String[] args){
      Thread t1 = new SampleThread();
      Thread t2 = new SampleThread();
      t1.start();  // starte den ersten Thread. Dies ruft die run() Methode auf.
      t2.start(); // Dies startet den 2. Thread. Dies ruft die run() Methode auf.
   }

   }

2. Implementieren Sie das java.lang.Runnable-Interface

   class A implements Runnable{

   @Override
   public void run() {
   
       // Führen Sie die run-Methode hier aus
   }
   
   public static void main() {
       final A obj = new A();
   
       Thread t1 = new Thread(new A());
   
       t1.start();
   }

   }

3. Implementieren Sie das java.util.concurrent.Callable-Interface

   class Counter implements Callable {

   private static final int THREAD_POOL_SIZE = 2;
   
   // Methode, in der die Thread-Ausführung stattfindet
   public String call() {
       return Thread.currentThread().getName() + " wird ausgeführt ...";
   }
   
   public static void main(String[] args) throws InterruptedException,
           ExecutionException {
       // Erstellen Sie einen Pool von 2 Threads
       ExecutorService executor = Executors
               .newFixedThreadPool(THREAD_POOL_SIZE);
   
       Future future1 = executor.submit(new Counter());
       Future future2 = executor.submit(new Counter());
   
       System.out.println(Thread.currentThread().getName() + " wird ausgeführt ...");
   
       // Holen Sie sich asynchron von den Worker-Threads
       System.out.println(future1.get());
       System.out.println(future2.get());
   
   }

   }

Bevorzugen Sie das Callable-Interface mit dem Executor-Framework für Thread-Pooling.

Das Runnable- oder Callable-Interface wird gegenüber der Erweiterung der Thread-Klasse bevorzugt

Answer 3

Oder Sie können ein Callable erstellen, das eine Schnittstelle ist, die ähnlich wie Runnable ist, mit der Ausnahme, dass sie eine Methode call definiert, die einen Wert zurückgeben kann. Um ein Callable zu instanziieren, können Sie es einem Executor übergeben. Sie finden eine ausführliche Erklärung von Multithreading und Callable-Beispielen hier

Answer 4

Der bevorzugte Weg, Threads in Java 6 zu starten, ist die Verwendung von Executors:

    ExecutorService es = Executors.newCachedThreadPool();
    Runnable r = ;
    es.execute(r);

Answer 5

Es gibt tatsächlich insgesamt 4 Möglichkeiten, einen Thread in Java zu erstellen:

1. Durch Erweitern der Klasse java.lang.Thread
2. Durch Implementieren des Interface java.lang.Runnable
3. Durch Verwendung einer anonymen inneren Klasse
4. Durch Implementieren des Interface Callable.