Dans Java , Avenir est un interface qui appartient à java.util.concurrent emballer . Il est utilisé pour représenter le résultat d’un calcul asynchrone. L'interface fournit les méthodes pour vérifier si le calcul est terminé ou non, pour attendre sa fin et pour récupérer le résultat du calcul. Une fois la tâche ou le calcul terminé, on ne peut pas annuler le calcul.
Syntaxe:
sous-chaîne Java
public interface Future
Exemple de Java Future
Le meilleur exemple de Java Future est ExécuteurService interface. Il produit un objet Future (à partir de certaines de leurs méthodes) pour suivre la progression d'une ou plusieurs tâches asynchrones.
Méthodes de la future interface
L'interface propose les cinq méthodes suivantes :
| Méthode | Description |
|---|---|
| Annuler() | Il tente d'annuler l'exécution de la tâche. |
| obtenir() | La méthode attend si nécessaire la fin du calcul, puis récupère son résultat. |
| obtenir() | Attend si nécessaire, au maximum le temps imparti pour que le calcul se termine, puis récupère son résultat, s'il est disponible. |
| est annulé() | Il renvoie vrai si la tâche a été annulée avant son achèvement. |
| est fait() | Il renvoie vrai si la tâche est terminée. |
Il y avait quelques lacunes dans l'interface Future qui sont les suivantes :
- En utilisant Future, le calcul ne peut pas être effectué manuellement.
- Il ne notifie pas une fois la commutation terminée.
- Sa chaîne ne peut pas être créée et combinée.
Afin de surmonter les limitations ci-dessus, Java8 introduit ComplétableFutur .
Utiliser Future dans la programmation asynchrone
Obtenir un résultat
Comme nous l'avons discuté ci-dessus, le Future représente le résultat d'une tâche asynchrone. Afin de récupérer le résultat de cette tâche asynchrone, l'interface Java Future fournit les deux versions suivantes des méthodes get() qui renvoient toutes deux un objet. Notez que le type de retour peut être un type générique. Par exemple:
Future future = ... // get Future by starting async task // do something else, until ready to check result via Future // get result from Future try { Object result = future.get(); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } Remarque : Si nous essayons d'invoquer la méthode get() avant la fin de la tâche asynchrone, la méthode get() se bloquera jusqu'à ce que le résultat soit prêt.
Afin de surmonter l'inconvénient ci-dessus, l'interface Future fournit une autre version de la méthode get() qui excepte une quantité de temps (en millisecondes) comme paramètre. Cela signifie que le futur attendra un certain temps pour terminer la tâche après que ce résultat soit disponible dans le futur. Par exemple:
types de tests de logiciels
try { Object result = future.get(1000, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { } catch (ExecutionException e) { } catch (TimeoutException e) { // thrown if timeout time interval passes // before a result is available. } Si Future n'obtient aucun résultat dans le délai imparti, un TimeoutException est projeté par le futur.
Annuler une tâche asynchrone
Nous pouvons également annuler une tâche asynchrone à tout moment en appelant le Annuler() méthode de l’interface Future. Par exemple:
bash divisé en chaîne
Future future = ... // Get Future from somewhere future.cancel();
Vérifiez si une tâche asynchrone est terminée
L'interface fournit une méthode est fait() pour vérifier si la tâche asynchrone est terminée ou non. Par exemple:
Future future = ... // Get Future from somewhere if(future.isDone()) { Object result = future.get(); } else { // do something else } Vérifier si une tâche asynchrone est annulée
L'interface Future fournit une méthode est annulé() pour vérifier si la tâche asynchrone représentée par Future est annulée ou non. Il renvoie vrai si la tâche est annulée avec succès, sinon renvoie faux. Par exemple:
Future future = ... // get Future from somewhere if(future.isCancelled()) { } else { } Exemple de Java Future
FutureExample.java
import java.util.concurrent.*; public class FutureExample { public static void main(String args[]) throws InterruptedException, ExecutionException { //ExecutorService allows us to execute tasks on threads asynchronously ExecutorService es = Executors.newSingleThreadExecutor(); //getting future //the method submit() submits a value-returning task for execution and returns the Future Future future = es.submit(() -> { //sleep thread for 2 seconds Thread.sleep(2000); return 'Welcome to Javatpoint'; }); //checks if the task is completed or not while(!future.isDone()) { System.out.println('The task is still in process.....'); //sleep thread for 2 milliseconds Thread.sleep(200); } System.out.println('Task completed! getting the result'); //getting the result after completing the task String result = future.get(); //prints the result System.out.println(result); es.shutdown(); } } Sortir:
