1. Conceito
Future representa o resultado de uma tarefa assíncrona que pode não ter sido concluída. O retorno de chamada pode ser adicionado a este resultado para executar as operações correspondentes após a execução da tarefa ser bem-sucedida ou falhar.
2. Interface futura
A interface Future define cinco métodos de interface principais RunnableFuture e ScheduleFuture herdam esta interface, e CompleteFuture e ForkJoinTask herdam esta interface.
3. Exemplos
teste de pacote;
importar java.util.concurrent.Callable;
importar java.util.concurrent.ExecutionException;
importar java.util.concurrent.FutureTask;
classe pública CallableFutureTest {
public static void main(String[] args) {
startTime longo = System.currentTimeMillis();
Callable<Integer> calculaCallable = new Callable<Integer>() {
@Substituir
chamada pública inteira() lança exceção {
// TODO stub de método gerado automaticamente
Thread.sleep(2000); //Simulação demorada int result = 1+2;
resultado de retorno;
}
};
FutureTask<Integer> calcularFutureTask = new FutureTask<>(calcularCallable);
Tópico t1 = novo Tópico(calcularFutureTask);
t1.start();
//Agora junte-se ao Thread para executar um serviço demorado que simula chamadas remotas e depende de seus resultados de cálculo (como uma calculadora de rede)
tentar {
//Simule tarefas demoradas, o thread principal faz seu próprio trabalho, refletindo as vantagens do multi-threading Thread.sleep(3000);
intuma = 3+5;
Resultado inteiro = calcularFutureTask.get();
System.out.println("result = "+(a+result));//Simula o resultado da execução do thread principal dependendo do subthread long endTime = System.currentTimeMillis();
System.out.println("time = "+(endTime-startTime)+"ms");
} catch (InterruptedException | ExecutionException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
} Como você pode ver acima, o tempo gasto acima é de cerca de 3s. Na verdade, é principalmente o tempo gasto pelo thread principal sleep (3000). o tempo que podemos precisar pode ser 5s (subthread 2s + thread principal 3s).
O que foi dito acima é como Future obtém resultados de thread em Java. Pode-se dizer que Future é mais flexível no processamento de threads. O mecanismo é aproximadamente que quando um thread está em execução, outro thread é executado ao mesmo tempo. Se você estiver interessado, poderá aprender mais depois da aula.