CKTIS / Java
Future.get: ottenere il risultato di un’attività o gestirne l’errore
Recupera il risultato di un’attività asincrona e distingui il suo errore da un’interruzione, un annullamento, la scadenza del tempo di attesa o un errore della chiamata a `invokeAll`.
Versione: Java SE 21
Sintassi
java.util.concurrent.Future<V>
V get() throws InterruptedException, ExecutionException
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutExceptionFuture.get recupera il risultato di un calcolo asincrono rappresentato da un java.util.concurrent.Future<V>. Senza argomenti, get() blocca il thread chiamante se necessario, senza limiti di tempo. In caso di successo restituisce un valore di tipo V, che può essere null se quello era il risultato dell’attività.
Se l’attività lancia un’eccezione, get() lancia ExecutionException. Usa getCause() per esaminare l’eccezione originale. InterruptedException indica invece che il thread chiamante è stato interrotto durante l’attesa, non che l’attività sia fallita. Se l’attività è stata annullata, get() lancia l’eccezione non controllata CancellationException.
L’overload get(long timeout, TimeUnit unit) ha gli stessi esiti possibili, ma limita il tempo di attesa. Se il tempo scade durante l’attesa, lancia TimeoutException. La scadenza da sola non annulla l’attività: puoi chiamare di nuovo get() in seguito.
Quando ExecutorService.invokeAll(tasks) termina normalmente, i Future sono già in uno stato finale e seguono l’ordine delle attività nella raccolta. isDone() non implica un successo: è get() sul Future dell’attività, non invokeAll, a segnalare l’eccezione dell’attività come ExecutionException. La chiamata a invokeAll può a sua volta essere interrotta durante l’attesa (InterruptedException) o non riuscire a pianificare un’attività (RejectedExecutionException). L’overload di invokeAll con limite di tempo annulla le attività non concluse prima di restituire il controllo; get() su un Future annullato lancia CancellationException.
Esempi
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class FutureGetExample {
public static void main(String[] args) throws InterruptedException {
List<Callable<Integer>> tasks = List.of(
() -> 21 * 2,
() -> { throw new IllegalStateException("invalid input"); }
);
try (ExecutorService executor = Executors.newSingleThreadExecutor()) {
List<Future<Integer>> futures = executor.invokeAll(tasks);
System.out.println("invokeAll returned");
for (Future<Integer> future : futures) {
try {
System.out.println("Result: " + future.get());
} catch (ExecutionException e) {
Throwable cause = e.getCause();
System.out.println("Task failed: " + cause.getClass().getSimpleName()
+ ": " + cause.getMessage());
}
}
}
}
}Risultato
invokeAll returned Result: 42 Task failed: IllegalStateException: invalid input
La prima riga mostra che `invokeAll` ha restituito normalmente il controllo. Il primo `get()` restituisce `42`; il secondo lancia `ExecutionException`. Il programma stampa il tipo e il messaggio della causa, non quelli dell’eccezione che la racchiude. Il blocco try-with-resources chiude l’esecutore.
Lezioni correlate
- Java · Lezione 50 · Intermedio · Versione: 2