CKTIS / Java
CompletableFuture.get(): esperar por um resultado
Usa `get()` para obter o resultado ou `get(timeout, unit)` para limitar a espera. Ao contrário de `join()`, ambas as variantes declaram exceções verificadas.
Versão: Java SE 21
Sintaxe
public T get() throws InterruptedException, ExecutionException
public T get(long timeout, java.util.concurrent.TimeUnit unit) throws InterruptedException, ExecutionException, java.util.concurrent.TimeoutExceptionEm Java SE 21, CompletableFuture.get é um método de instância de java.util.concurrent.CompletableFuture<T>. Uma chamada a get() só bloqueia a thread que fez a chamada se tiver de esperar pela conclusão. Se o objeto já estiver concluído, não há espera; em caso de sucesso, o método devolve o resultado do tipo T.
Ambas as sobrecargas lançam InterruptedException se a thread que fez a chamada for interrompida durante a espera, ou ExecutionException se o cálculo falhar. Usa getCause() para consultar a causa da falha. Se o próprio objeto for cancelado, é lançada a exceção não verificada CancellationException. As exceções verificadas têm de ser capturadas ou declaradas com throws.
get(long timeout, TimeUnit unit) limita a espera, por exemplo com future.get(2, TimeUnit.SECONDS). Se o prazo expirar antes da conclusão, a chamada lança a exceção verificada TimeoutException; a expiração do prazo não cancela nem conclui o objeto.
join() também pode bloquear e lança igualmente CancellationException em caso de cancelamento, mas não declara exceções verificadas: uma falha do cálculo é comunicada através da exceção não verificada CompletionException. Para processar o resultado sem bloquear no ponto da chamada, encadeia uma etapa como thenApply.
Exemplos
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class Main {
public static void main(String[] args) throws InterruptedException, ExecutionException {
CompletableFuture<Integer> pending = new CompletableFuture<>();
try {
pending.get(0, TimeUnit.MILLISECONDS);
throw new AssertionError("Expected a timeout");
} catch (TimeoutException e) {
System.out.println("Timed out");
}
pending.complete(42);
System.out.println("Result: " + pending.get());
CompletableFuture<Integer> failed =
CompletableFuture.failedFuture(new IllegalStateException("No result"));
try {
failed.get();
} catch (ExecutionException e) {
System.out.println("get cause: " + e.getCause().getMessage());
}
try {
failed.join();
} catch (CompletionException e) {
System.out.println("join cause: " + e.getCause().getMessage());
}
}
}Resultado
Timed out Result: 42 get cause: No result join cause: No result
O limite de espera de zero provoca `TimeoutException`, porque `pending` ainda não está concluído. Após `complete(42)`, `get()` devolve `42` sem esperar. Por fim, `get()` e `join()` mostram a mesma causa da falha, encapsulada em duas exceções diferentes.
Lições relacionadas
- Java · Lição 51 · Intermédio · Versão: 2