3 Möglichkeiten zum Erstellen von Threads in Java und ihre Unterschiede

Wie erstelle ich einen Thread in Java? Der folgende Artikel stellt Ihnen drei Möglichkeiten zum Erstellen von Threads und ihre Unterschiede vor. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird für alle hilfreich sein.

Wenn Sie einen Thread in Java erstellen möchten, gibt es im Allgemeinen drei Methoden:

Erben Sie die Thread-Klasse; 2. Implementieren Sie die Runnable-Schnittstelle.

3. Verwenden Sie Callable und Future, um Threads zu erstellen.

[Empfohlenes Lernen:

]

1. Erben Sie die Thread-Klasse Erben Für die Thread-Klasse müssen Sie die Ausführungsmethode überschreiben und die Aufgaben definieren, die in der Ausführungsmethode ausgeführt werden müssen.

class MyThread extends Thread{
    private static int num = 0;
     
    public MyThread(){
        num++;
    }
     
    @Override
    public void run() {
        System.out.println("主动创建的第"+num+"个线程");
    }
}

Nachdem Sie Ihre eigene Thread-Klasse erstellt haben, können Sie ein Thread-Objekt erstellen und dann den Thread über die start()-Methode starten. Beachten Sie, dass die run()-Methode nicht zum Starten des Threads aufgerufen wird. Wenn die run-Methode aufgerufen wird, entspricht dies der Ausführung der run-Methode im Hauptthread Es gibt keinen Unterschied zu gewöhnlichen Methodenaufrufen. Zu diesem Zeitpunkt wird kein neuer Thread erstellt, um die definierten Aufgaben auszuführen.

public class Test {
    public static void main(String[] args)  {
        MyThread thread = new MyThread();
        thread.start();
    }
}
 
 
class MyThread extends Thread{
    private static int num = 0;
     
    public MyThread(){
        num++;
    }
     
    @Override
    public void run() {
        System.out.println("主动创建的第"+num+"个线程");
    }
}

Im obigen Code wird durch Aufrufen der start()-Methode ein neuer Thread erstellt. Um den Unterschied zwischen dem Methodenaufruf start() und dem Methodenaufruf run() zu unterscheiden, sehen Sie sich bitte das folgende Beispiel an:

public class Test {
    public static void main(String[] args)  {
        System.out.println("主线程ID:"+Thread.currentThread().getId());
        MyThread thread1 = new MyThread("thread1");
        thread1.start();
        MyThread thread2 = new MyThread("thread2");
        thread2.run();
    }
}
 
 
class MyThread extends Thread{
    private String name;
     
    public MyThread(String name){
        this.name = name;
    }
     
    @Override
    public void run() {
        System.out.println("name:"+name+" 子线程ID:"+Thread.currentThread().getId());
    }
}

Laufergebnisse:

Aus den Ausgabeergebnissen können die folgenden Schlussfolgerungen gezogen werden:

1) Die Thread-IDs von Thread1 und Thread2 sind unterschiedlich, und Thread2 und die Haupt-Thread-ID sind gleich, was darauf hinweist, dass dies beim Aufruf der Ausführungsmethode der Fall ist Erstellt keinen neuen Thread, sondern wird direkt im Hauptthread ausgeführt. Die Ausführungsmethode unterscheidet sich nicht von gewöhnlichen Methodenaufrufen.

2) Obwohl die Startmethode von Thread1 vor der Ausführungsmethode von Thread2 aufgerufen wird, werden die Informationen angezeigt Im Zusammenhang mit dem Aufruf der Ausführungsmethode von Thread2 wird zuerst ausgegeben, was darauf hinweist, dass der neue Prozess der Thread-Erstellung die nachfolgende Ausführung des Hauptthreads nicht blockiert.

2. Implementieren Sie die Runnable-Schnittstelle Zusätzlich zum Erben der Thread-Klasse kann das Erstellen eines Threads in Java auch durch Implementierung etwas Ähnliches erreichen die Runnable-Schnittstellenfunktion. Die Implementierung der Runnable-Schnittstelle muss deren Ausführungsmethode überschreiben.

Das Folgende ist ein Beispiel:

public class Test {
    public static void main(String[] args)  {
        System.out.println("主线程ID："+Thread.currentThread().getId());
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}
 
 
class MyRunnable implements Runnable{
     
    public MyRunnable() {
         
    }
     
    @Override
    public void run() {
        System.out.println("子线程ID："+Thread.currentThread().getId());
    }
}

Die chinesische Bedeutung von Runnable ist „Aufgabe“. Wie der Name schon sagt, definieren wir durch die Implementierung der Runnable-Schnittstelle eine Unteraufgabe und übergeben die Unteraufgabe zum Thread zur Ausführung. Beachten Sie, dass diese Methode Runnable als Parameter der Thread-Klasse verwenden und dann die Startmethode von Thread verwenden muss, um einen neuen Thread zur Ausführung der Unteraufgabe zu erstellen. Wenn Sie die run-Methode von Runnable aufrufen, wird kein neuer Thread erstellt. Dieser normale Methodenaufruf macht keinen Unterschied.

Wenn Sie sich den Implementierungsquellcode der Thread-Klasse ansehen, werden Sie feststellen, dass die Thread-Klasse die Runnable-Schnittstelle implementiert.

In Java können diese beiden Methoden verwendet werden, um Threads zur Ausführung von Unteraufgaben zu erstellen. Welche Methode Sie wählen, hängt von Ihren eigenen Anforderungen ab. Das direkte Erben der Thread-Klasse sieht möglicherweise einfacher aus als das Implementieren der Runnable-Schnittstelle. Da Java jedoch nur eine einzelne Vererbung zulässt, kann eine benutzerdefinierte Klasse, wenn sie andere Klassen erben muss, nur die Implementierung der Runnable-Schnittstelle auswählen.

3. Verwenden Sie Callable und Future, um Threads zu erstellen Im Gegensatz zur Runnable-Schnittstelle bietet die Callable-Schnittstelle eine call()-Methode für die Thread-Ausführung body ist die call()-Methode leistungsfähiger als die run()-Methode.

Die Schritte zum Erstellen und Starten eines Threads mit einem Rückgabewert lauten wie folgt:

1. Verwenden Sie die FutureTask-Klasse, um das Callable-Objekt zu umschließen, das den Rückgabewert der call()-Methode des Callable-Objekts kapselt.
2. Verwenden Sie das FutureTask-Objekt als Ziel des zu erstellenden Thread-Objekts und starten Sie den Thread (da FutureTask die Runnable-Schnittstelle implementiert hat)
3. Rufen Sie die get()-Methode des FutureTask-Objekts auf, um den Rückgabewert zu erhalten, nachdem der Unterthread ausgeführt wurde
4. The Es folgt ein Beispiel:

public class Main {

　　public static void main(String[] args){

　　　MyThread3 th=new MyThread3();

　　　//使用Lambda表达式创建Callable对象

　　   //使用FutureTask类来包装Callable对象

　　　FutureTask<Integer> future=new FutureTask<Integer>(

　　　　(Callable<Integer>)()->{

　　　　　　return 5;

　　　　}

　　  );

　　　new Thread(task,"有返回值的线程").start();//实质上还是以Callable对象来创建并启动线程

　　  try{

　　　　System.out.println("子线程的返回值："+future.get());//get()方法会阻塞，直到子线程执行结束才返回

 　　 }catch(Exception e){

　　　　ex.printStackTrace();

　　　}

　　}

}

Vergleich von drei Möglichkeiten zum Erstellen von Threads: Die Methoden zur Implementierung von Runnable- und Callable-Schnittstellen sind im Grunde die gleichen , aber letztere hat einen Rückgabewert, wenn die Methode call() des Thread-Ausführungskörpers keinen Rückgabewert hat, sodass diese beiden Methoden in eine Kategorie eingeteilt werden können. Der Unterschied zwischen dieser Methode und der Methode erben Die Thread-Klasse lautet wie folgt:

1. Threads implementieren nur Runnable Oder implementieren die Callable-Schnittstelle und erben andere Klassen.

2. Auf diese Weise können mehrere Threads ein Zielobjekt gemeinsam nutzen, was sehr gut für Situationen geeignet ist, in denen mehrere Threads dieselbe Ressource verarbeiten.

3. Die Programmierung ist jedoch etwas kompliziert. Wenn Sie auf den aktuellen Thread zugreifen müssen, müssen Sie die Methode Thread.currentThread() aufrufen.

4. Eine Thread-Klasse, die die Thread-Klasse erbt, kann keine anderen übergeordneten Klassen erben (Java-Einzelvererbungsentscheidung).

Dieser Artikel stammt aus der Kolumne Java-Einführung, willkommen zum Lernen!

Das obige ist der detaillierte Inhalt von3 Möglichkeiten zum Erstellen von Threads in Java und ihre Unterschiede. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!