I Java tillader multithreading at køre opgaver samtidigt, hvilket forbedrer ydeevnen og reaktionsevnen. Traditionelt brugte udviklere den Runnable-grænseflade til at definere opgaver, men den har to store begrænsninger: den kan ikke returnere et resultat og kan ikke kaste kontrollerede undtagelser. For at overvinde disse introducerede Java de Callable og Future-grænseflader i Java 5.
Kaldbar grænseflade
De Kaldbar grænseflade repræsenterer en opgave, der returnerer et resultat og kan medføre en undtagelse. Det ligner Runnable, men mere fleksibelt, da det kan returnere en værdi og afgive kontrollerede undtagelser.
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
Forklaring: En Callable opgave indsendes til bobestyreren. Den beregner summen af tal fra 1 til 5 og returnerer resultatet. Resultatet hentes ved hjælp af future.get() efter opgaven er færdig.
Fremtidig grænseflade
De Fremtidig grænseflade repræsenterer resultatet af en asynkron beregning. Når du sender en Callable eller Runnable opgave til en ExecutorService, returnerer den et 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
Forklaring: DeCallableopgaven beregner10 + 2 and ExecutorService.submit()metode returnerer enFutureobjekt. Brugerfuture.get()vi får resultatet, når beregningen er fuldført.
Callable vs Future
| Feature | Ringbar | Fremtid |
|---|---|---|
| Formål | Repræsenterer en opgave, der returnerer et resultat | Repræsenterer resultatet af en asynkron opgave |
| Returtype | Returnerer et resultat, når det udføres | Beholder resultatet returneret af en Callable |
| Defineret i | java.util.concurrent-pakke | java.util.concurrent-pakke |
| Udførelse | Indsendt til ExecutorService | Returneret af ExecutorService.submit() |
| Metoder | Har én metode call() | Har metoder som get() isDone() cancel() |
| Undtagelseshåndtering | Kan smide kontrollerede undtagelser | Håndterer resultater og undtagelser efter eksekvering |
| Brug | Definerer, hvad der skal udføres | Styrer overvåger og henter resultatet af en opgave |