Mehrere Möglichkeiten, Multithreading in Java zu implementieren

Es gibt drei Möglichkeiten, Java-Multithreading zu verwenden: die Thread-Klasse erben, die Runnable-Schnittstelle implementieren und Callable und Future zum Erstellen von Threads verwenden.

1. Die Thread-Klasse erben

Die Implementierung ist sehr einfach. Sie müssen lediglich eine Klasse erstellen, um die Thread-Klasse zu erben und zu überschreiben Die Ausführungsmethode kann durch Aufrufen der Startmethode des Instanzobjekts dieser Klasse in der Hauptmethode erreicht werden. Code:

public class MyThread extends Thread {
    @Override
    public void run(){        
        super.run();
        System.out.println("执行子线程...");
    }
}

Testfall:

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println("主线程...");
    }
}

Laufergebnis:

Natürlich stellen die Ergebnisse hier nicht die Ausführungsreihenfolge von dar Die Threads werden gleichzeitig ausgeführt. Wenn sie mehrmals ausgeführt werden, kann die Druckreihenfolge unterschiedlich sein. Während der Multithread-Ausführung führt die CPU Threads auf unsichere Weise aus, sodass die Ausführungsergebnisse nichts mit der Ausführungsreihenfolge des Codes oder der Aufrufreihenfolge zu tun haben und die Ausführungsergebnisse auch unterschiedlich sein können.

Empfohlene kostenlose Video-Tutorials: Java-Lernvideo

Ein weiterer zu beachtender Punkt ist, dass die Startmethode von myThread in der Hauptmethode und nicht in run() aufgerufen werden sollte. Verfahren. Der Aufruf der start()-Methode teilt der CPU mit, dass dieser Thread zur Ausführung bereit ist, und das System führt seine run()-Methode aus, wenn es Zeit hat.

Beim direkten Aufruf der run()-Methode wird diese nicht asynchron, sondern synchron nacheinander ausgeführt, wie beim Aufrufen einer Funktion, wodurch die Bedeutung von Multithreading verloren geht.

2. Implementieren Sie die Runnable-Schnittstelle

Die Implementierung dieser Methode ist ebenfalls sehr einfach, nämlich die zu implementierende geerbte Thread-Klasse zu ändern die Runnable-Schnittstelle. Der Code lautet wie folgt:

public class MyRunnable implements Runnable {    
    @Override
    public void run() {
        System.out.println("执行子线程...");
    }
}

Testfall:

public class Test {    
    public static void main(String[] args) {
        Runnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
        System.out.println("主线程运行结束!");
    }
}

Laufergebnis:

Das Laufergebnis ist nichts zu sagen, Sie kann es hier im Wesentlichen sehen. Wenn es darum geht, tatsächlich einen neuen Thread zu erstellen, wird er immer noch über Thread erstellt:

Thread thread = new Thread(runnable);

Die Rolle der Thread-Klasse in diesem Schritt besteht darin, die run()-Methode in einen Thread zu packen Ausführungskörper, und verwenden Sie dann weiterhin Start, um dem System mitzuteilen, dass der Thread zur geplanten Implementierung bereit ist.

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

Die beiden oben genannten Methoden haben diese beiden Probleme:

1. Der Rückgabewert des untergeordneten Threads kann nicht abgerufen werden.

2. Die Ausführungsmethode kann keine Ausnahme auslösen.

Um diese beiden Probleme zu lösen, müssen wir die Callable-Schnittstelle verwenden. Apropos Schnittstellen: Die obige Instanz der Runnable-Schnittstellenimplementierungsklasse wird als Parameter des Konstruktors der Thread-Klasse übergeben und dann wird der Inhalt in der Ausführungsmethode durch den Start von Thread ausgeführt. Callable ist jedoch keine Unterschnittstelle von Runnable, sondern eine brandneue Schnittstelle. Ihre Instanz kann nicht direkt an das Thread-Konstrukt übergeben werden, daher ist eine andere Schnittstelle erforderlich, um sie zu konvertieren.

Java5 stellt die Future-Schnittstelle zur Darstellung des Rückgabewerts der call()-Methode in der Callable-Schnittstelle bereit und stellt eine Implementierungsklasse FutureTask für die Future-Schnittstelle bereit. Die Vererbungsbeziehung der Implementierungsklasse ist wie in der Abbildung dargestellt Abbildung:

Wie Sie sehen, implementiert diese Implementierungsklasse nicht nur die Future-Schnittstelle, sondern auch die Runnable-Schnittstelle, sodass sie direkt an den Thread-Konstruktor übergeben werden kann.

Der Konstruktor von FutureTask lautet wie folgt:

Es gibt also tatsächlich einen Konvertierungsprozess mehr als bei der vorherigen Methode, und letztendlich wird durch den Thread-Start ein neuer Thread erstellt. Mit dieser Idee ist der Code leicht zu verstehen:

import java.util.concurrent.Callable;
public class MyCallable implements Callable {    
int i = 0;    
@Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"  i的值："+ i);        
        return i++; //call方法可以有返回值
    }
}

Test:

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class Test {
    public static void main(String[] args) {
        Callable callable = new MyCallable();        
        for (int i = 0; i < 10; i++) {
            FutureTask task = new FutureTask(callable);            
            new Thread(task,"子线程"+ i).start();            
            try {                //获取子线程的返回值
                System.out.println("子线程返回值："+task.get() + "\n");
            }  catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

Ausführungsergebnis (Teil):

Verwandt empfohlen Artikel-Tutorials: Java-Einstiegsprogramm

Das obige ist der detaillierte Inhalt vonMehrere Möglichkeiten, Multithreading in Java zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!