Welche Möglichkeiten gibt es, Multithreading in Java zu implementieren?

Vorwort

Es gibt vier Hauptmethoden zum Implementieren von Java-Multithreading:

① Erben Sie die Thread-Klasse, implementieren Sie die Runnable-Schnittstelle.

② Implementieren Sie die Callable-Schnittstelle, um Thread-Threads über den FutureTask-Wrapper zu erstellen.

③ Verwenden Sie ExecutorService, Callable

④ Zukünftige Implementierung von Multithreading mit Rückgabeergebnissen

Die ersten beiden Methoden haben keinen Rückgabewert, nachdem der Thread ausgeführt wurde, und die letzten beiden Methoden haben Rückgabewerte.

1. Vier Möglichkeiten, Multithreading zu implementieren

1. Erben Sie die Thread-Klasse, um einen Thread zu erstellen. Die Thread-Klasse ist im Wesentlichen eine Instanz, die die Runnable-Schnittstelle implementiert und eine Instanz eines Threads darstellt. Die Verwendung der start()-Instanzmethode der Thread-Klasse ist die einzige Möglichkeit, einen Thread zu starten. Ein neuer Thread, der die run()-Methode ausführt, wird durch Aufrufen der start()-Methode gestartet, bei der es sich um eine native Methode handelt. Es ist sehr einfach, Multithreading auf diese Weise zu implementieren, indem Sie Thread direkt durch Ihre eigene Klasse erweitern und die run()-Methode überschreiben. Sie können einen neuen Thread starten und Ihre eigene definierte run()-Methode ausführen. Beispiel:

public class MyThread extends Thread {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}  
MyThread myThread1 = new MyThread();  
MyThread myThread2 = new MyThread();  
myThread1.start();  
myThread2.start();

2. Implementieren Sie die Runnable-Schnittstelle, um einen Thread zu erstellen.

Wenn Ihre Klasse eine andere Klasse erweitert hat, können Sie zu diesem Zeitpunkt eine Runnable-Schnittstelle wie folgt implementieren:

public class MyThread extends OtherClass implements Runnable {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}

In Um MyThread zu starten, müssen Sie zunächst einen Thread instanziieren und Ihre eigene MyThread-Instanz übergeben:

MyThread myThread = new MyThread();  
Thread thread = new Thread(myThread);  
thread.start();

Wenn tatsächlich ein Runnable-Zielparameter an Thread übergeben wird, ruft die run()-Methode von Thread target.run() auf, siehe zum JDK-Quellcode:

public void run() {  
　　if (target != null) {  
　　 target.run();  
　　}  
}

3. Implementieren Sie die Callable-Schnittstelle

Erstellen Sie einen Thread-Thread über den FutureTask-Wrapper

Die Callable-Schnittstelle (hat auch nur eine Methode) ist wie folgt definiert:

public interface Callable<V>   { 
  V call（） throws Exception;   } 
public class SomeCallable<V> extends OtherClass implements Callable<V> {
    @Override
    public V call() throws Exception {
        // TODO Auto-generated method stub
        return null;
    }
}

rrree

4. Implementieren Sie einen Thread das Ergebnisse zurückgibt

Verwenden Sie ExecutorService-, Callable- und Future-Implementierungsthreads, die Ergebnisse zurückgeben

ExecutorService-, Callable- und Future-Schnittstellen gehören tatsächlich zum Executor-Framework. In JDK1.5 werden Threads, die Ergebnisse zurückgeben, als neue Funktion eingeführt, sodass Sie sich keine Mühe mehr machen müssen, den Rückgabewert zu erhalten. Und selbst wenn Sie es selbst implementieren, kann es voller Lücken sein.

Aufgaben, die Werte zurückgeben können, müssen die Callable-Schnittstelle implementieren. Ebenso müssen Aufgaben, die keinen Wert zurückgeben, die Runnable-Schnittstelle implementieren.

Nachdem Sie die Callable-Aufgabe ausgeführt haben, können Sie einen Future-Objektaufruf für das Objekt abrufen, um das von der Callable-Aufgabe zurückgegebene Objekt abzurufen.

Hinweis: Die Get-Methode blockiert, das heißt: Der Thread gibt kein Ergebnis zurück und die Get-Methode wartet ewig.

In Kombination mit der Thread-Pool-Schnittstelle ExecutorService können Sie das legendäre Multithreading realisieren, das Ergebnisse liefert.

Es wurde unter JDK1.5 verifiziert und es gibt kein Problem. Sie können das unten angegebene Multithread-Testbeispiel mit den zurückgegebenen Ergebnissen direkt verwenden. Der Code lautet wie folgt:

Callable<V> oneCallable = new SomeCallable<V>();   
//由Callable<Integer>创建一个FutureTask<Integer>对象：   
FutureTask<V> oneTask = new FutureTask<V>(oneCallable);   
//注释：FutureTask<Integer>是一个包装器，它通过接受Callable<Integer>来创建，它同时实现了Future和Runnable接口。 
  //由FutureTask<Integer>创建一个Thread对象：   
Thread oneThread = new Thread(oneTask);   
oneThread.start();   //至此，一个线程就创建完成了。

2. Multithreading-bezogenes Wissen

1. Der Unterschied zwischen Runnable und Callable

Der Hauptunterschied besteht darin, dass die Runnable-Schnittstellenaufrufmethode keinen Rückgabewert hat ein Rückgabewert und unterstützt die generische Runnable-Schnittstellen-Ausführungsmethode. Sie kann nur Laufzeitausnahmen auslösen und diese nicht abfangen zwischen dem Aufruf der Start- und Run-Methode

Thread-Objektaufruf Die Run-Methode startet den Thread nicht. Nur Objekte rufen Methoden auf.

Die Thread-Objektaufrufe beginnen, den Thread zu öffnen, und ermöglichen es der JVM, die Ausführungsmethode im geöffneten Thread aufzurufen. Durch Aufrufen der Startmethode kann der Thread gestartet und in den Bereitschaftszustand versetzt werden, und die Ausführungsmethode ist einfach Eine normale Thread-Methode oder im Haupt-Thread implementieren.

3. Grundlegende Methoden im Zusammenhang mit Threads

Zu den grundlegenden Methoden im Zusammenhang mit Threads gehören Wait, Notify, NotifyAll, Sleep, Join, Yield usw.

Thread Waiting (Warten) Der Thread, der diese Methode aufruft, wechselt in den Wartezustand und kann Nur auf andere Threads warten Es wird nur zurückgegeben, wenn es benachrichtigt oder unterbrochen wird. Es ist zu beachten, dass nach dem Aufruf der Methode wait () die Sperre des Objekts aufgehoben wird. Daher wird die Wartemethode im Allgemeinen in synchronisierten Methoden oder synchronisierten Codeblöcken verwendet.

Thread-Sleep (Sleep) Sleep bewirkt, dass der aktuelle Thread in den Ruhezustand versetzt wird. Sleep gibt die aktuell belegte Sperre nicht frei. Sleep (long) führt dazu, dass der Thread in den TIMED-WATING-Status wechselt. Die Methode bewirkt, dass der aktuelle Thread in den Ruhezustand wechselt.

Thread yield (Yield) yield führt dazu, dass der aktuelle Thread die CPU-Ausführungszeit aufgibt und erneut mit anderen Threads um die CPU-Zeitscheibe konkurriert. Im Allgemeinen haben Threads mit hoher Priorität eine größere Chance, erfolgreich um CPU-Zeitscheiben zu konkurrieren, dies gilt jedoch nicht unbedingt. Einige Betriebssysteme reagieren nicht empfindlich auf Thread-Priorität.

Thread-Unterbrechung (Interrupt) Die ursprüngliche Absicht der Unterbrechung eines Threads besteht darin, dem Thread ein Benachrichtigungssignal zu geben, das sich auf ein Interrupt-Flag innerhalb des Threads auswirkt. Aus diesem Grund wird der Status dieses Threads selbst nicht geändert (z. B. Blockieren, Beenden usw.). Join wartet darauf, dass andere Threads die Methode join () beenden, und ruft die Methode join () auf Ein Thread im aktuellen Thread, dann der aktuelle Thread Übergang in den Blockierungszustand, Rückkehr zu einem anderen Thread zum Beenden, der aktuelle Thread wechselt vom Blockierungszustand in den Bereitschaftszustand und wartet auf die Gunst der CPU.

Thread-Wakeup (Notify) Die notify()-Methode in der Object-Klasse weckt einen einzelnen Thread, der auf diesem Objektmonitor wartet, wird einer der Threads zum Wecken ausgewählt ist willkürlich und tritt auf, wenn eine Entscheidung über die Implementierung getroffen wird. Der Thread wartet auf dem Monitor des Objekts, indem er eine der wait()-Methoden aufruft. Der aufgeweckte Thread kann die Ausführung nicht fortsetzen, bis der aktuelle Thread die Sperre für dieses Objekt aufgibt konkurriert auf normale Weise mit allen anderen Threads, die sich aktiv auf dem Objekt synchronisieren. Eine weitere ähnliche Methode ist notifyAll(), die alle Threads aufweckt, die auf demselben Monitor warten.

4. Der Unterschied zwischen wait() und sleep()

① Kommt aus verschiedenen Klassen wait(): kommt aus der Object-Klasse; ② Bezüglich der Freigabe von Sperren: wait( ): Warten Die Sperre wird während des Wartevorgangs aufgehoben; Sleep(): Die Sperre wird während des Wartevorgangs nicht aufgehoben

③ Verwendungsbereich: Wait(): muss im synchronisierten Codeblock verwendet werden Sleep(); : kann überall verwendet werden;

④ Ob Ausnahmen abgefangen werden sollen; Sleep(): Ausnahmen müssen abgefangen werden.

Multi-Threading-Prinzip: wird gleichzeitig durchgeführt. Für eine CPU kann sie zu einem bestimmten Zeitpunkt nur ein Programm ausführen, das heißt, sie kann nur einen Prozess gleichzeitig ausführen. Die CPU wechselt ständig zwischen diesen Prozessen und jeder Thread wird einmal ausgeführt. Da die Ausführungsgeschwindigkeit der CPU im Verhältnis zu unserer Wahrnehmung zu hoch ist, haben wir zwar das Gefühl, dass mehrere Prozesse gleichzeitig ausgeführt werden, obwohl die CPU die Ausführung zwischen mehreren Prozessen wechselt.

Die CPU wechselt zwischen mehreren Prozessen. Wenn wir zu viele Programme öffnen, wird auch die Zeit, die die CPU benötigt, um zu jedem Prozess zu wechseln, länger und wir werden auch das Gefühl haben, dass die Maschine langsamer läuft. Obwohl der sinnvolle Einsatz von Multithreading die Effizienz verbessern kann, führt ein übermäßiger Einsatz nicht zu Effizienzsteigerungen.

Die Multithreading-Technologie löst hauptsächlich das Problem der Ausführung mehrerer Threads in der Prozessoreinheit. Sie kann die Leerlaufzeit der Prozessoreinheit erheblich reduzieren und die Durchsatzkapazität der Prozessoreinheit erhöhen.

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