I Java tillåter multithreading att uppgifter körs samtidigt, vilket förbättrar prestanda och lyhördhet. Traditionellt använde utvecklare Runnable-gränssnittet för att definiera uppgifter, men det har två stora begränsningar: det kan inte returnera ett resultat och kan inte kasta markerade undantag. För att övervinna dessa introducerade Java gränssnitten Callable och Future i Java 5.
Anropsbart gränssnitt
De Anropsbart gränssnitt representerar en uppgift som returnerar ett resultat och kan orsaka ett undantag. Det liknar Runnable men mer flexibelt eftersom det kan returnera ett värde och kasta markerade undantag.
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(); } }
Produktion
Result: 15
Förklaring: En Callable uppgift lämnas till utföraren. Den beräknar summan av siffror från 1 till 5 och returnerar resultatet. Resultatet hämtas med future.get() efter att uppgiften är klar.
Framtida gränssnitt
De Framtida gränssnitt representerar resultatet av en asynkron beräkning. När du skickar en Callable eller Runnable uppgift till en ExecutorService returnerar den ett Future-objekt.
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(); } } }
Produktion
Result: 30
Förklaring: DeCallableuppgiften beräknar10 + 2 and ExecutorService.submit()metod returnerar enFutureobjekt. Använderfuture.get()vi får resultatet när beräkningen är klar.
Callable vs Future
| Särdrag | Ringbar | Framtida |
|---|---|---|
| Ändamål | Representerar en uppgift som returnerar ett resultat | Representerar resultatet av en asynkron uppgift |
| Returtyp | Returnerar ett resultat när det körs | Behåller resultatet som returneras av en Callable |
| Definierat i | java.util.concurrent-paket | java.util.concurrent-paket |
| Utförande | Inlämnad till ExecutorService | Returneras av ExecutorService.submit() |
| Metoder | Har en metod call() | Har metoder som get() isDone() cancel() |
| Undantagshantering | Kan kasta markerade undantag | Hanterar resultat och undantag efter utförande |
| Användande | Definierar vad som ska utföras | Kontroller övervakar och hämtar resultatet av en uppgift |