In Java maakt multithreading het mogelijk dat taken gelijktijdig worden uitgevoerd, waardoor de prestaties en het reactievermogen worden verbeterd. Traditioneel gebruikten ontwikkelaars de Runnable-interface om taken te definiëren, maar deze heeft twee belangrijke beperkingen: er kan geen resultaat worden geretourneerd en er kunnen geen gecontroleerde uitzonderingen worden gegenereerd. Om deze te overwinnen introduceerde Java de Callable en Future interfaces in Java 5.
Oproepbare interface
De Oproepbare interface vertegenwoordigt een taak die een resultaat retourneert en een uitzondering kan opleveren. Het is vergelijkbaar met Runnable, maar flexibeler omdat het een waarde kan retourneren en gecontroleerde uitzonderingen kan genereren.
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(); } }
Uitvoer
Result: 15
Uitleg: Er wordt een opvraagbare taak ingediend bij de uitvoerder. Het berekent de som van de getallen van 1 tot en met 5 en retourneert het resultaat. Het resultaat wordt opgehaald met future.get() nadat de taak is voltooid.
Toekomstige interface
De Toekomstige interface vertegenwoordigt het resultaat van een asynchrone berekening. Wanneer u een opvraagbare of uitvoerbare taak indient bij een ExecutorService, retourneert deze een Future-object.
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(); } } }
Uitvoer
Result: 30
Uitleg: DeCallabletaak berekeningen10 + 2 and ExecutorService.submit()methode retourneert aFuturevoorwerp. Gebruikenfuture.get()we krijgen het resultaat zodra de berekening is voltooid.
Opvraagbaar versus toekomstig
| Functie | Oproepbaar | Toekomst |
|---|---|---|
| Doel | Vertegenwoordigt een taak die een resultaat retourneert | Vertegenwoordigt het resultaat van een asynchrone taak |
| Retourtype | Retourneert een resultaat wanneer het wordt uitgevoerd | Bevat het resultaat dat is geretourneerd door een Callable |
| Gedefinieerd in | java.util.concurrent-pakket | java.util.concurrent-pakket |
| Uitvoering | Verzonden naar ExecutorService | Geretourneerd door ExecutorService.submit() |
| Methoden | Heeft één methodeaanroep() | Heeft methoden zoals get() isDone() cancel() |
| Afhandeling van uitzonderingen | Kan gecontroleerde uitzonderingen genereren | Verwerkt resultaten en uitzonderingen na uitvoering |
| Gebruik | Definieert wat moet worden uitgevoerd | Controls bewaakt en haalt het resultaat van een taak op |