En Java , Futur és un interfície que pertany a java.util.concurrent paquet . S'utilitza per representar el resultat d'un càlcul asíncron. La interfície proporciona els mètodes per comprovar si el càlcul s'ha completat o no, per esperar-ne la finalització i per recuperar el resultat del càlcul. Un cop finalitzada la tasca o el càlcul, no es pot cancel·lar el còmput.
Sintaxi:
public interface Future
Exemple de Java Future
El millor exemple de Java Future és Servei d'execució interfície. Produeix un objecte Futur (a partir d'alguns dels seus mètodes) per fer el seguiment del progrés d'una o més tasques asíncrones.
Mètodes de la interfície del futur
La interfície ofereix els cinc mètodes següents:
| Mètode | Descripció |
|---|---|
| cancel · lar() | Intenta cancel·lar l'execució de la tasca. |
| aconseguir() | El mètode espera, si cal, que es completi el càlcul i després recupera el seu resultat. |
| aconseguir() | Espera si és necessari, com a màxim durant el temps donat perquè es completi el càlcul, i després recupera el seu resultat, si està disponible. |
| està cancel·lat() | Torna veritable si la tasca s'ha cancel·lat abans de la seva finalització. |
| està fet() | Torna veritable si s'ha completat la tasca. |
Hi havia algunes mancances de la interfície Future que són les següents:
- Amb Future, el càlcul no es pot completar manualment.
- No notifica un cop finalitzada la commutació.
- La seva cadena no es pot crear ni combinar.
Per superar les limitacions anteriors, Java 8 introduït CompletableFuture .
Ús de Future en programació asíncrona
Obtenció del resultat
Com hem comentat anteriorment, el futur representa el resultat d'una tasca asíncrona. Per tal de recuperar el resultat d'aquesta tasca asíncrona, la interfície de Java Future proporciona les dues versions següents dels mètodes get() que retornen un objecte. Tingueu en compte que el tipus de retorn pot ser un tipus genèric. Per 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(); } Nota: si intentem invocar el mètode get() abans de completar la tasca asíncrona, el mètode get() es bloquejarà fins que el resultat estigui llest.
Per tal de superar la mancança anterior, la interfície Future proporciona una altra versió del mètode get() que excepte una quantitat de temps (en mil·lisegons) com a paràmetre. Representa que el futur esperarà una quantitat de temps per completar la tasca després que aquest resultat estigui disponible en el futur. Per exemple:
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 no obté cap resultat en el temps especificat, a TimeoutException és llançat pel futur.
Cancel·la una tasca asíncrona
També podem cancel·lar una tasca asíncrona en qualsevol moment cridant a cancel · lar() mètode de la interfície del futur. Per exemple:
Future future = ... // Get Future from somewhere future.cancel();
Comproveu si s'ha fet una tasca asíncrona
La interfície proporciona un mètode està fet() per comprovar si la tasca asíncrona s'ha completat o no. Per exemple:
Future future = ... // Get Future from somewhere if(future.isDone()) { Object result = future.get(); } else { // do something else } Comproveu si una tasca asíncrona està cancel·lada
La interfície Future proporciona un mètode està cancel·lat() per comprovar si la tasca asíncrona representada per Future està cancel·lada o no. Torna true si la tasca es cancel·la correctament, en cas contrari retorna false. Per 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(); } } Sortida:
