Programación paralela utilizando Callable and Future
La forma más común de realizar una programación paralela en Java es heredar la clase de subprocesos o implementar la interfaz ejecutable. La desventaja de estos dos métodos es que el resultado de la ejecución no se puede obtener directamente después de que se complete la tarea, y debe comunicarse a través de variables compartidas o entre hechos, lo cual es inconveniente de usar.
A partir de Java 1.5, se proporcionan interfaces llamables y futuras. Al usarlos, puede obtener el resultado de ejecución después de ejecutar la tarea.
Aprendamos a usar Callable, Future y FuturetAk.
Interfaz llamable
La interfaz invocatoria se encuentra en el paquete java.util.concurrent. Esta es una interfaz genérica que solo declara un método de llamada ():
Interfaz pública Callable <T> {t call () lanza una excepción;}En general, se usa junto con la interfaz EjecutorService. Varios métodos de envío sobrecargados se declaran en la interfaz EjecutsorService:
<t> futuro <t> enviar (task cableable <t>); <t> futuro <t> Subt (Tarea Runnable, t Result); Future <?> Subt (Runnable Task);
El tipo de parámetro en el primer método de envío se puede llamar, y los otros dos no están cubiertos por este artículo por el momento.
Future and Futuretask
La clase de implementación de la interfaz futura puede realizar operaciones como cancelar, consultar y obtener resultados en tareas ejecutables o llamables.
La interfaz futura también se encuentra debajo del paquete java.util.concurrent:
Public Interface Future <T> { /***Cancelar tarea*@param MayInterruptiNning*¿Permite la cancelación de las tareas que se están ejecutando pero no completadas? Si se establece verdadero, significa que la tarea en el proceso se puede cancelar *Si la tarea se ejecuta, devuelve verdadero *Si la tarea aún no se ha ejecutado, devuelve verdadero si MayInterruptifrunning es verdadero o falso */ boolean Cancel (boolean MayInterrupruptiNning); /***¿La tarea se cancela correctamente? Si se cancela correctamente antes de que la tarea se complete normalmente, devuelve verdadero */ boolean isCancelled (); / ***¿La tarea se completa*/ boolean isDone (); / ***Obtenga el resultado de la ejecución a través del bloqueo*/ t get () lanza interruptedException, ExecutionException; /***Obtenga el resultado de ejecución a través del bloqueo. Si no se devuelve ninguna devolución dentro del tiempo especificado, return null */ t get (tiempo de espera largo, unidad de tiempo de tiempo) lanza interruptedException, ExecutionException, TimeOutException;}En resumen, Future proporciona tres funciones:
Determinar si la tarea se completa y puede interrumpir la tarea y obtener el resultado de la ejecución de la tarea
JDK nos proporciona una clase de implementación de interfaz futura FutUreTask, que tiene los siguientes dos constructores.
Public FutUreTask (Callable <T> Callable) {} public FutURETASK (Runnable Runnable, T Result) {} Código de muestra
Usando el futuro, el futuro
import java.util.concurrent.*; prueba de clase pública {public static void main (string [] args) {ExecutorService ExecutorService = Ejecutors.newCachedThreadPool (); Tarea tarea = nueva tarea (); Futuro <integer> futuro = ExecutorService.submit (tarea); EjecutorService.shutdown (); System.out.println ("El hilo principal es ejecutar la tarea ..."); intente {Thread.sleep (2000); } catch (InterruptedException ex) {Ex.PrintStackTrace (); } try {System.out.println ("Task Ejecutar resultado:"+futuro.get ()); } catch (InterruptedException ex) {Ex.PrintStackTrace (); } Catch (ExecutionException ex) {Ex.PrintStackTrace (); } System.out.println ("Todas las tareas se han ejecutado"); }} Tarea de clase Implementa Callable <Integer> {@Override public Integer Call () lanza la excepción {System.out.println ("El hilo infantil está ejecutando la tarea ..."); // La tarea de simulación lleva tiempo Thread.sleep (5000); regresar 1000; }}Resultados de la ejecución:
El hilo infantil está ejecutando la tarea ... el hilo principal está ejecutando la tarea ... Resultado de la operación de la tarea: 1000 todas las tareas se han ejecutado
Use llamable, FuturetASk
import java.util.concurrent.*; prueba de clase pública {public static void main (string [] args) {ExecutorService ExecutorService = Ejecutors.newCachedThreadPool (); Tarea tarea = nueva tarea (); FUTURETASK <Integer> FUTURETASK = new FutUreTask <integer> (tarea); EjecutorService.submit (FuturetAk); EjecutorService.shutdown (); System.out.println ("El hilo principal es ejecutar la tarea ..."); intente {Thread.sleep (2000); } catch (InterruptedException ex) {Ex.PrintStackTrace (); } try {System.out.println ("Task Ej. } catch (InterruptedException ex) {Ex.PrintStackTrace (); } Catch (ExecutionException ex) {Ex.PrintStackTrace (); } System.out.println ("Todas las tareas se ejecutan"); }} Tarea de clase Implementa Callable <Integer> {@Override public Integer Call () lanza la excepción {System.out.println ("El hilo infantil está ejecutando la tarea ..."); // simular la tarea lleva hilo.sleep (5000); regresar 1000; }}Resultados de la ejecución:
El hilo infantil está ejecutando la tarea ... el hilo principal está ejecutando la tarea ... Resultado de la operación de la tarea: 1000 todas las tareas se han ejecutado
Resumir
Lo anterior es todo el contenido de este artículo sobre el uso de Callable and Future para la programación paralela en Java. Espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!