Interfaces llamables y futuras
Callable es una interfaz similar a Runnable.
Existen varias diferencias entre Callable y Runnable:
(1) El método especificado por Callable es Call (), mientras que el método especificado por Runnable es run ().
(2) La tarea llamable puede devolver el valor después de que se ejecute, mientras que la tarea ejecutable no puede devolver el valor.
(3) El método de llamada () puede lanzar excepciones, mientras que el método run () no puede lanzar excepciones.
(4) Ejecute la tarea invocable y puede obtener un objeto futuro.
Proporciona un método para verificar si el cálculo se completa, para esperar a que se complete el cálculo y recuperar los resultados del cálculo.
A través del objeto futuro, puede comprender el estado de ejecución de la tarea, cancelar la ejecución de la tarea y también obtener los resultados de la ejecución de la tarea.
La copia del código es la siguiente:
paquete com.yao;
import java.util.concurrent.callable;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
import java.util.concurrent.future;
clase pública CallableAndFuture {
/**
* Personalizar una clase de tareas para implementar la interfaz calificable
*/
clase pública estática myCallableClass implementa invocatoria {
// Posición del logotipo
Private int Flag = 0;
public myCallableClass (int flag) {
this.flag = flag;
}
public String llamado () lanza la excepción {
if (this.flag == 0) {
// Si el valor de la bandera es 0, regrese inmediatamente
return "flag = 0";
}
if (this.flag == 1) {
// Si el valor de la bandera es 1, haga un bucle infinito
intentar {
while (verdadero) {
System.out.println ("Looping ...");
Thread.sleep (2000);
}
} capt (interruptedException e) {
System.out.println ("interrumpido");
}
devolver "falso";
} demás {
// Si el falso no es 0 o 1, se lanzará una excepción
arrojar una nueva excepción ("¡Valor malo de la bandera!");
}
}
}
public static void main (string [] args) {
// Definir 3 tareas de tipos calificables
MyCallableClass Task1 = new MyCallableClass (0);
MyCallableClass Task2 = new MyCallableClass (1);
MyCallableClass Task3 = new MyCallableClass (2);
// crear un servicio que realice tareas
EjecutorService es = ejecutors.newFixedThreadPool (3);
intentar {
// Enviar y ejecutar la tarea.
// Si desea obtener el resultado de la ejecución o excepción de la tarea, puede operar en este objeto futuro
Future Future1 = es.submit (Tarea1);
// Obtenga el resultado de la primera tarea.
System.out.println ("Tarea1:" + Future1.get ());
Future Future2 = es.submit (tarea2);
// Espere 5 segundos antes de detener la segunda tarea. Porque la segunda tarea es un bucle infinito
Thread.sleep (5000);
System.out.println ("Tarea2 Cancel:" + Future2.Cancel (True));
// Obtener la salida de la tercera tarea, porque ejecutar la tercera tarea causará una excepción
// Entonces, la siguiente declaración causará la excepción
Future Future3 = es.submit (tarea3);
System.out.println ("Tarea3:" + Future3.get ());
} Catch (Exception e) {
System.out.println (e.ToString ());
}
// Detener el servicio de ejecución de tareas
es.shutdownnow ();
}
}