Em Java , Futuro é um interface que pertence a java.util.concurrent pacote . É usado para representar o resultado de uma computação assíncrona. A interface fornece métodos para verificar se o cálculo foi concluído ou não, para aguardar sua conclusão e para recuperar o resultado do cálculo. Depois que a tarefa ou cálculo for concluído, não será possível cancelar o cálculo.
Sintaxe:
public interface Future
Exemplo de futuro Java
O melhor exemplo de Java Future é ExecutorService interface. Ele produz um objeto Future (de alguns de seus métodos) para rastrear o progresso de uma ou mais tarefas assíncronas.
Métodos da Interface do Futuro
A interface fornece os cinco métodos a seguir:
| Método | Descrição |
|---|---|
| cancelar() | Tenta cancelar a execução da tarefa. |
| pegar() | O método espera, se necessário, que o cálculo seja concluído e então recupera seu resultado. |
| pegar() | Aguarda, se necessário, no máximo o tempo determinado para a conclusão do cálculo e, em seguida, recupera seu resultado, se disponível. |
| é cancelado() | Retorna verdadeiro se a tarefa foi cancelada antes de sua conclusão. |
| é feito() | Ele retorna verdadeiro se a tarefa for concluída. |
Houve algumas deficiências na interface Future que são as seguintes:
- Usando Future, o cálculo não pode ser concluído manualmente.
- Não avisa quando a comutação é concluída.
- Sua cadeia não pode ser criada e combinada.
Para superar as limitações acima, Java 8 introduzido CompletávelFuturo .
Usando Future em Programação Assíncrona
Obtendo Resultado
Como discutimos acima, o Futuro representa o resultado de uma tarefa assíncrona. Para recuperar o resultado dessa tarefa assíncrona, a interface Java Future fornece as duas versões a seguir dos métodos get(), ambas retornando um objeto. Observe que o tipo de retorno pode ser um tipo genérico. Por exemplo:
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 tentarmos invocar o método get() antes que a tarefa assíncrona seja concluída, o método get() será bloqueado até que o resultado esteja pronto.
Para superar a deficiência acima, a interface Future fornece outra versão do método get() que exclui uma quantidade de tempo (em milissegundos) como parâmetro. Representa que o Futuro aguardará um certo tempo para concluir a tarefa após esse resultado estar disponível no Futuro. Por exemplo:
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 não obtiver nenhum resultado dentro do tempo especificado, um TimeoutException é lançada pelo Futuro.
Cancelar uma tarefa assíncrona
Também podemos cancelar uma tarefa assíncrona a qualquer momento chamando o método cancelar() método da interface Future. Por exemplo:
Future future = ... // Get Future from somewhere future.cancel();
Verifique se uma tarefa assíncrona foi concluída
A interface fornece um método é feito() para verificar se a tarefa assíncrona foi concluída ou não. Por exemplo:
Future future = ... // Get Future from somewhere if(future.isDone()) { Object result = future.get(); } else { // do something else } Verifique se uma tarefa assíncrona foi cancelada
A interface Future fornece um método é cancelado() para verificar se a tarefa assíncrona representada por Future foi cancelada ou não. Ele retorna verdadeiro se a tarefa for cancelada com sucesso, caso contrário, retorna falso. Por exemplo:
Future future = ... // get Future from somewhere if(future.isCancelled()) { } else { } Exemplo de 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(); } } Saída:
