Dieser Artikel bietet Ihnen eine Einführung (Code) in die drei Methoden zum Erstellen von Threads in Java. Ich hoffe, dass er Ihnen als Referenz dienen wird.
Wenn Sie einen Thread in Java erstellen möchten, gibt es im Allgemeinen drei Methoden:
Erben Sie die Thread-Klasse
Implementierung Runnable-Schnittstelle;
Verwenden Sie Callable und Future, um Threads zu erstellen.
1. Erben Sie die Thread-Klasse
Wenn Sie die Thread-Klasse erben, müssen Sie die Ausführungsmethode überschreiben und die erforderlichen Aufgaben definieren in der run-Methode durchgeführt werden.
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, schauen 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());
}
}Laufergebnis:
Aus den Ausgabeergebnissen können folgende 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 die Ausführungsmethode aufgerufen wird erstellt keinen neuen Thread, sondern im Hauptthread. Das direkte Ausführen der Ausführungsmethode unterscheidet sich nicht von gewöhnlichen Methodenaufrufen
2) Obwohl die Startmethode von Thread1 vor der Ausführungsmethode von Thread2 aufgerufen wird, ist die Zuerst werden Informationen zum Aufruf der Ausführungsmethode von Thread2 ausgegeben, was darauf hinweist, dass der Prozess der Erstellung eines neuen Threads die nachfolgende Ausführung des Hauptthreads nicht blockiert.
2. Implementieren Sie die Runnable-Schnittstelle
Zusätzlich zum Erben der Thread-Klasse beim Erstellen eines Threads in Java können Sie auch ähnliche Funktionen implementieren, indem Sie die Runnable-Schnittstelle implementieren. 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 zum Ausführen 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 scheint einfacher zu sein 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 als Thread-Ausführungskörper, den call( )-Methode Es ist leistungsfähiger als die run()-Methode.
Die Schritte zum Erstellen und Starten eines Threads mit einem Rückgabewert sind wie folgt:
Erstellen Sie eine Implementierungsklasse der Callable-Schnittstelle, implementieren Sie die Methode call(), und erstellen Sie dann die Implementierungsklasse Instanz (ab Java8 können Sie Lambda-Ausdrücke direkt verwenden, um aufrufbare Objekte zu erstellen).
Verwenden Sie die FutureTask-Klasse, um das Callable-Objekt zu umschließen, die den Rückgabewert der call()-Methode des Callable-Objekts kapselt
Verwenden das FutureTask-Objekt Erstellen und starten Sie einen Thread als Ziel des Thread-Objekts (da FutureTask die Runnable-Schnittstelle implementiert)
Rufen Sie die get()-Methode des FutureTask-Objekts auf, um den Rückgabewert zu erhalten nachdem die Ausführung des untergeordneten Threads abgeschlossen ist
Das Folgende ist 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:
Implementieren von Runnable und Implementieren von Callable-Schnittstellen Die Methoden sind grundsätzlich gleich, mit der Ausnahme, dass letztere beim Ausführen der Methode call() einen Rückgabewert haben und letztere beim Ausführen der Methode run() keinen Rückgabewert haben Daher können diese beiden Methoden in eine Klasse eingeteilt werden. Diese Methode ist dieselbe wie die Methode, die die Thread-Klasse erbt. Die Unterschiede sind wie folgt:
Threads Implementieren Sie nur Runnable oder die Callable-Schnittstelle und können Sie auch andere Klassen erben.
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.
Aber die Programmierung ist etwas kompliziert. Wenn Sie auf den aktuellen Thread zugreifen müssen, müssen Sie die Methode Thread.currentThread() aufrufen.
Eine Thread-Klasse, die die Thread-Klasse erbt, kann keine anderen übergeordneten Klassen erben (Java-Einzelvererbungsentscheidung).
PS: Es wird generell empfohlen, Multithreads durch die Implementierung von Schnittstellen zu erstellen
Das obige ist der detaillierte Inhalt vonEinführung in 3 Methoden zum Erstellen von Threads in Java (Code). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
