In Giava , Futuro è un interfaccia quello appartiene a java.util.concurrent pacchetto . Viene utilizzato per rappresentare il risultato di un calcolo asincrono. L'interfaccia fornisce i metodi per verificare se il calcolo è stato completato o meno, per attendere il suo completamento e per recuperare il risultato del calcolo. Una volta completata l'attività o il calcolo, non è possibile annullare il calcolo.
Sintassi:
public interface Future
Esempio di futuro Java
Il miglior esempio di Java Future è ExecutorService interfaccia. Produce un oggetto Future (da alcuni dei loro metodi) per tenere traccia dell'avanzamento di una o più attività asincrone.
Metodi dell'interfaccia futura
L'interfaccia fornisce i seguenti cinque metodi:
| Metodo | Descrizione |
|---|---|
| Annulla() | Tenta di annullare l'esecuzione dell'attività. |
| Ottenere() | Il metodo attende, se necessario, il completamento del calcolo, quindi recupera il risultato. |
| Ottenere() | Se necessario, attende al massimo il tempo specificato per il completamento del calcolo, quindi recupera il risultato, se disponibile. |
| èCancellato() | Restituisce vero se l'attività è stata annullata prima del suo completamento. |
| è fatta() | Restituisce vero se l'attività è stata completata. |
C'erano alcuni difetti dell'interfaccia Future che sono i seguenti:
- Utilizzando Future, il calcolo non può essere completato manualmente.
- Non avvisa una volta completata la commutazione.
- La sua catena non può essere creata e combinata.
Per superare le limitazioni di cui sopra, Giava8 introdotto CompletabileFuturo .
Utilizzo del futuro nella programmazione asincrona
Ottenere il risultato
Come abbiamo discusso in precedenza, il Futuro rappresenta il risultato di un compito asincrono. Per recuperare il risultato di tale attività asincrona, l'interfaccia Java Future fornisce le seguenti due versioni dei metodi get() che restituiscono entrambe un oggetto. Tieni presente che il tipo restituito potrebbe essere un tipo generico. Per esempio:
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: se proviamo a invocare il metodo get() prima che l'attività asincrona sia completata, il metodo get() si bloccherà finché il risultato non sarà pronto.
Per superare il limite di cui sopra, l'interfaccia Future fornisce un'altra versione del metodo get() che esclude una quantità di tempo (in millisecondi) come parametro. Rappresenta che il Futuro attenderà un certo periodo di tempo per completare l'attività dopo che il risultato sarà disponibile nel Futuro. Per esempio:
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. } Se Future non ottiene alcun risultato entro il tempo specificato, a TimeoutException viene lanciato dal Futuro.
Annulla un'attività asincrona
Possiamo anche annullare un'attività asincrona in qualsiasi momento chiamando il file Annulla() metodo dell'interfaccia Future. Per esempio:
Future future = ... // Get Future from somewhere future.cancel();
Controlla se un'attività asincrona è stata eseguita
L'interfaccia fornisce un metodo è fatta() per verificare se l'attività asincrona è stata completata o meno. Per esempio:
Future future = ... // Get Future from somewhere if(future.isDone()) { Object result = future.get(); } else { // do something else } Controlla se un'attività asincrona è stata annullata
L'interfaccia Future fornisce un metodo èCancellato() per verificare se l'attività asincrona rappresentata da Future è annullata o meno. Restituisce true se l'attività viene annullata con successo, altrimenti restituisce false. Per esempio:
Future future = ... // get Future from somewhere if(future.isCancelled()) { } else { } Esempio di futuro Java
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(); } } Produzione:
