Eine kurze Diskussion über die Verwendung von Callable und Future für parallele Programmierung in Java

Parallele Programmierung mit Callable und Future

Die häufigste Möglichkeit, eine parallele Programmierung in Java durchzuführen, besteht darin, die Thread -Klasse zu erben oder die Runnable -Schnittstelle zu implementieren. Der Nachteil dieser beiden Methoden besteht darin, dass das Ausführungsergebnis nicht direkt nach Abschluss der Aufgabe erzielt werden kann, und es muss durch gemeinsame Variablen oder Inter-Threads kommuniziert werden, was zu verwenden ist.

Ab Java 1.5 werden Callable und zukünftige Schnittstellen bereitgestellt. Durch die Verwendung können Sie das Ausführungsergebnis nach der Ausführung der Aufgabe erhalten.

Lassen Sie uns lernen, wie man Callable, Future und Futuretask verwendet.

Callable -Schnittstelle

Die Callable -Schnittstelle befindet sich im Paket java.util.concurrent. Dies ist eine generische Schnittstelle, die nur eine Call () -Methode deklariert:

 öffentliche Schnittstelle Callable <T> {t call () löst Ausnahme aus;}

Im Allgemeinen wird es in Verbindung mit der Executorservice -Schnittstelle verwendet. Mehrere überlastete Sugic -Methoden werden in der ExecutorService -Schnittstelle deklariert:

 <t> Future <T> Subjekt (Callable <T> Task); <T> Future <T> Subjekt (Runnable Task, T -Ergebnis); Future <?> Subjekt (Runnable Task);

Der Parametertyp in der ersten Sugic -Methode ist aufrufbar und die anderen beiden sind vorerst nicht in diesem Artikel abgedeckt.

Zukunft und Futuretask

Die Implementierungsklasse der zukünftigen Schnittstelle kann Vorgänge wie Stornieren, Abfragen und Erzählen von Ergebnissen zu Runnable- oder Callable -Aufgaben ausführen.

Die zukünftige Schnittstelle befindet sich auch unter dem Paket java.util.Concurrent:

 öffentliche Schnittstelle zu Future <T> { /***Aufgabe abbrechen*@param im MaiinruptiFrunning*Ermöglicht es eine Aufhebung von Aufgaben, die ausgeführt werden, aber nicht abgeschlossen werden? Wenn True festgelegt ist, bedeutet dies, dass die Aufgabe im Prozess abgebrochen werden kann *Wenn die Aufgabe ausgeführt wird, gibt sie True *zurück *Wenn die Aufgabe noch nicht ausgeführt wurde, gibt es True zurück, ob ein Maiinterruptifrunning wahr oder falsch */ boolean abbrechen (boolean MayInterruptIffrunning); /***Wird die Aufgabe erfolgreich abgesagt? Wenn es erfolgreich abgesagt wird, bevor die Aufgabe normal abgeschlossen ist, gibt es true */ boolean iscancelled () zurück. / ***wird die Aufgabe erledigt*/ boolean isdone (); / ***das Ausführungsergebnis durch Blockieren erhalten*/ t Get () löst InterruptedException, ExecutionException aus; /***Holen Sie sich das Ausführungsergebnis durch Blockierung. Wenn innerhalb der angegebenen Zeit keine Rückgabe zurückgegeben wird, gibt NULL */ T GET (langfristig, Zeiteinheit) InterruptedException, ExecutionException, TimeoutException;} aus

Zusammenfassend bietet Future drei Funktionen:

 Stellen Sie fest, ob die Aufgabe erledigt ist, und kann die Aufgabe unterbrechen und das Ergebnis der Aufgabenausführung erhalten

JDK bietet uns ein zukünftiges FutureTask -Futuretask mit der zukünftigen Schnittstelle, das die folgenden zwei Konstruktoren hat.

 public futuretask (Callable <T> Callable) {} Public Futuretask (Runnable Runnable, T Ergebnis) {}

Beispielcode

Mit Callable, Zukunft

 Java.util.Concurrent importieren. Task Task = new Task (); Future <Ganzzahl> Future = ExecutorService.Submit (Aufgabe); ExecutorService.Shutdown (); System.out.println ("Der Haupt -Thread wird die Aufgabe ausführen ..."); try {thread.sleep (2000); } catch (InterruptedException ex) {ex.printstacktrace (); } try {system.out.println ("Task -Run -Ergebnis:"+future.get ()); } catch (InterruptedException ex) {ex.printstacktrace (); } catch (executionException ex) {ex.printstacktrace (); } System.out.println ("Alle Aufgaben wurden ausgeführt"); }} class Task implementiert Callable <Integer> {@Override public Integer call () löst eine Ausnahme aus {System.out.println ("Child Thread wird Aufgabe ausführen ..."); // Simulationsaufgabe braucht Zeit Thread.sleep (5000); Rückkehr 1000; }}

Ausführungsergebnisse:

 Der untergeordnete Thread wird die Aufgabe ausführen

Verwenden Sie Callable, Futuretask

 Java.util.Concurrent importieren. Task Task = new Task (); Futuretask <Gearner> futuretask = new futuretask <Gearner> (Aufgabe); ExecutorService.Submit (Futuretask); ExecutorService.Shutdown (); System.out.println ("Der Haupt -Thread wird die Aufgabe ausführen ..."); try {thread.sleep (2000); } catch (InterruptedException ex) {ex.printstacktrace (); } try {System.out.println ("Task -Run -Ergebnis:"+futuretask.get ()); } catch (InterruptedException ex) {ex.printstacktrace (); } catch (executionException ex) {ex.printstacktrace (); } System.out.println ("Alle Aufgaben werden ausgeführt"); }} class Task implementiert Callable <Integer> {@Override public Integer call () löst Ausnahme aus {System.out.println ("Der untergeordnete Thread wird die Aufgabe ausführen ..."); // Simulation der Aufgabe nimmt Thread.Sleep (5000); Rückkehr 1000; }}

Ausführungsergebnisse:

 Der untergeordnete Thread wird die Aufgabe ausführen

Zusammenfassen

Das obige ist der gesamte Inhalt dieses Artikels über die Verwendung von Callable und Future für parallele Programmierung in Java. Ich hoffe, es wird für alle hilfreich sein. Interessierte Freunde können weiterhin auf andere verwandte Themen auf dieser Website verweisen. Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen. Vielen Dank an Freunde für Ihre Unterstützung für diese Seite!