En Java, le multithreading permet aux tâches de s'exécuter simultanément, améliorant ainsi les performances et la réactivité. Traditionnellement, les développeurs utilisaient l'interface Runnable pour définir des tâches, mais elle présente deux limitations majeures : elle ne peut pas renvoyer de résultat et ne peut pas lever d'exceptions vérifiées. Pour surmonter ces problèmes, Java a introduit les interfaces Callable et Future dans Java 5.
Interface appelable
Le Interface appelable représente une tâche qui renvoie un résultat et peut lever une exception. Il est similaire à Runnable mais plus flexible car il peut renvoyer une valeur et lancer des exceptions vérifiées.
balançoire javaJava
import 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(); } }
Sortir
Result: 15
Explication: Une tâche appelable est soumise à l'exécuteur. Il calcule la somme des nombres de 1 à 5 et renvoie le résultat. Le résultat est récupéré à l'aide de future.get() une fois la tâche terminée.
Interface future
Le Future interface représente le résultat d'un calcul asynchrone. Lorsque vous soumettez une tâche Callable ou Runnable à un ExecutorService, elle renvoie un objet Future.
méthodes de chaîne en JavaJava
import 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(); } } }
Sortir
Result: 30
Explication: LeCallablela tâche calcule10 + 2 and ExecutorService.submit()la méthode renvoie unFutureobjet. En utilisantfuture.get()nous obtenons le résultat une fois le calcul terminé.
Appelable vs futur
| Fonctionnalité | Appelable | Avenir |
|---|---|---|
| But | Représente une tâche qui renvoie un résultat | Représente le résultat d'une tâche asynchrone |
| Type de retour | Renvoie un résultat lors de l'exécution | Contient le résultat renvoyé par un Callable |
| Défini dans | paquet java.util.concurrent | paquet java.util.concurrent |
| Exécution | Soumis à ExecutorService | Renvoyé par ExecutorService.submit() |
| Méthodes | Possède un seul appel de méthode() | A des méthodes comme get() isDone() Cancel() |
| Gestion des exceptions | Peut lancer des exceptions vérifiées | Gère les résultats et les exceptions après l'exécution |
| Usage | Définit ce qu'il faut exécuter | Controls surveille et récupère le résultat d’une tâche |