In Java ermöglicht Multithreading die gleichzeitige Ausführung von Aufgaben, wodurch Leistung und Reaktionsfähigkeit verbessert werden. Traditionell verwendeten Entwickler die Runnable-Schnittstelle zum Definieren von Aufgaben, diese weist jedoch zwei wesentliche Einschränkungen auf: Sie kann kein Ergebnis zurückgeben und keine geprüften Ausnahmen auslösen. Um diese zu überwinden, führte Java in Java 5 die Callable- und Future-Schnittstellen ein.
Aufrufbare Schnittstelle
Der Aufrufbare Schnittstelle stellt eine Aufgabe dar, die ein Ergebnis zurückgibt und möglicherweise eine Ausnahme auslöst. Es ähnelt Runnable, ist jedoch flexibler, da es einen Wert zurückgeben und geprüfte Ausnahmen auslösen kann.
Javaimport java.util.concurrent.*; public class CallableExample { public static void main(String[] args) throws Exception { ExecutorService executor = Executors.newSingleThreadExecutor(); Callable<Integer> task = () -> { int sum = 0; for (int i = 1; i <= 5; i++) sum += i; return sum; // returns result }; Future<Integer> future = executor.submit(task); System.out.println('Result: ' + future.get()); executor.shutdown(); } }
Ausgabe
Result: 15
Erläuterung: Eine aufrufbare Aufgabe wird an den Ausführenden übermittelt. Es berechnet die Summe der Zahlen von 1 bis 5 und gibt das Ergebnis zurück. Das Ergebnis wird nach Abschluss der Aufgabe mit „future.get()“ abgerufen.
Zukünftige Schnittstelle
Der Zukünftige Schnittstelle stellt das Ergebnis einer asynchronen Berechnung dar. Wenn Sie eine aufrufbare oder ausführbare Aufgabe an einen ExecutorService senden, wird ein Future-Objekt zurückgegeben.
Javaimport java.util.concurrent.*; public class CallableFutureExample { public static void main(String[] args) { ExecutorService executor = Executors.newSingleThreadExecutor(); Future<Integer> future = executor.submit(() -> 10 + 20); try { Integer result = future.get(); // waits but returns instantly System.out.println('Result: ' + result); } catch (Exception e) { e.printStackTrace(); } finally { executor.shutdown(); } } }
Ausgabe
Result: 30
Erläuterung: DerCallableAufgabe berechnet10 + 2 and ExecutorService.submit()Methode gibt a zurückFutureObjekt. Benutzenfuture.get()Wir erhalten das Ergebnis, sobald die Berechnung abgeschlossen ist.
Callable vs. Future
| Besonderheit | Abrufbar | Zukunft |
|---|---|---|
| Zweck | Stellt eine Aufgabe dar, die ein Ergebnis zurückgibt | Stellt das Ergebnis einer asynchronen Aufgabe dar |
| Rückgabetyp | Gibt bei der Ausführung ein Ergebnis zurück | Enthält das von einem Callable zurückgegebene Ergebnis |
| Definiert in | java.util.concurrent-Paket | java.util.concurrent-Paket |
| Ausführung | An ExecutorService übermittelt | Zurückgegeben von ExecutorService.submit() |
| Methoden | Hat eine Methode call() | Hat Methoden wie get() isDone() cancel() |
| Ausnahmebehandlung | Kann geprüfte Ausnahmen auslösen | Behandelt Ergebnisse und Ausnahmen nach der Ausführung |
| Verwendung | Definiert, was ausgeführt werden soll | Steuert überwacht und ruft das Ergebnis einer Aufgabe ab |