Interfaces chamáveis e futuras
Callable é uma interface semelhante ao Runnable.
Existem várias diferenças entre chamadas e executáveis:
(1) O método especificado por Callable é Call (), enquanto o método especificado pelo Runnable é executado ().
(2) A tarefa chamada pode retornar o valor após a execução, enquanto a tarefa executável não pode retornar o valor.
(3) O método Call () pode lançar exceções, enquanto o método run () não pode lançar exceções.
(4) Execute a tarefa chamada e você pode obter um objeto futuro.
Ele fornece um método para verificar se o cálculo é concluído, para aguardar a conclusão do cálculo e recuperar os resultados do cálculo.
Por meio do objeto futuro, você pode entender o status de execução da tarefa, cancelar a execução da tarefa e também obter os resultados da execução da tarefa.
A cópia do código é a seguinte:
pacote com.yao;
importar java.util.Concurrent.Callable;
importar java.util.concurrent.executorService;
importar java.util.concurrent.executores;
importar java.util.concurrent.future;
classe pública CallableAndFuture {
/**
* Personalize uma classe de tarefa para implementar a interface chamada
*/
Classe estática pública MyCallableClass implementa chamáveis {
// Posição do logotipo
private int flag = 0;
public MyCallableClass (int sinaliza) {
this.flag = sinalizador;
}
public String Call () lança Exceção {
if (this.flag == 0) {
// Se o valor da bandeira for 0, retorne imediatamente
retornar "sinalizador = 0";
}
if (this.flag == 1) {
// Se o valor da bandeira for 1, faça um loop infinito
tentar {
while (true) {
System.out.println ("Looping ...");
Thread.sleep (2000);
}
} catch (interruptedException e) {
System.out.println ("interrompido");
}
retornar "falso";
} outro {
// Se o false não for 0 ou 1, uma exceção será lançada
lançar uma nova exceção ("Valor de bandeira ruim!");
}
}
}
public static void main (string [] args) {
// define 3 tarefas de tipos chamáveis
MyCallableClass tarefa1 = new MyCallableClass (0);
MyCallableClass Task2 = new MyCallableClass (1);
MyCallableClass Task3 = new MyCallableClass (2);
// Crie um serviço que execute tarefas
ExecutorService ES = executores.newfixedThreadpool (3);
tentar {
// Envie e execute a tarefa.
// Se você deseja obter o resultado da execução ou exceção de tarefas, você pode operar neste futuro objeto
Futuro futuro1 = es.submit (tarefa1);
// Obtenha o resultado da primeira tarefa.
System.out.println ("Task1:" + Future1.get ());
Futuro futuro2 = es.submit (Task2);
// Aguarde 5 segundos antes de interromper a segunda tarefa. Porque a segunda tarefa é um loop infinito
Thread.sleep (5000);
System.out.println ("Task2 Cancel:" + FUTURO2.CANCEL (TRUE));
// Obtenha a saída da terceira tarefa, porque a execução da terceira tarefa causará uma exceção
// Portanto, a seguinte declaração fará com que a exceção seja lançada
Futuro futuro3 = es.submit (tarefa3);
System.out.println ("Task3:" + futuro3.get ());
} catch (Exceção e) {
System.out.println (e.toString ());
}
// Pare o serviço de execução de tarefas
es.shutdownnow ();
}
}