Java Callable y Future se utilizan mucho en la programación multiproceso. En las últimas publicaciones, aprendimos mucho sobre los subprocesos de Java , pero a veces deseamos que un subproceso pueda devolver algún valor que podamos usar. Java 5 introdujo la interfaz java.util.concurrent.Callable en el paquete de concurrencia, que es similar a la interfaz Runnable, pero puede devolver cualquier objeto y generar una excepción.
Java invocable
La interfaz Java Callable utiliza Generic para definir el tipo de retorno de Object. La clase Executors proporciona métodos útiles para ejecutar Java Callable en un grupo de subprocesos. Dado que las tareas invocables se ejecutan en paralelo, tenemos que esperar a que se devuelva Object.
Futuro de Java
Las tareas invocables de Java devuelven el objeto java.util.concurrent.Future . Con el objeto Future de Java , podemos averiguar el estado de la tarea invocable y obtener el objeto devuelto. Proporciona el método get() que puede esperar a que finalice la invocable y luego devolver el resultado. Java Future proporciona el método cancel() para cancelar la tarea invocable asociada. Hay una versión sobrecargada del método get() donde podemos especificar el tiempo de espera para el resultado, es útil para evitar que el hilo actual se bloquee durante más tiempo. Hay métodos isDone() e isCancelled() para averiguar el estado actual de la tarea invocable asociada. Aquí hay un ejemplo simple de una tarea invocable de Java que devuelve el nombre del hilo que ejecuta la tarea después de un segundo. Estamos usando el marco Executor para ejecutar 100 tareas en paralelo y usamos Java Future para obtener el resultado de las tareas enviadas.
package com.journaldev.threads;import java.util.ArrayList;import java.util.Date;import java.util.List;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;public class MyCallable implements CallableString { @Override public String call() throws Exception { Thread.sleep(1000); //return the thread name executing this callable task return Thread.currentThread().getName(); } public static void main(String args[]){ //Get ExecutorService from Executors utility class, thread pool size is 10 ExecutorService executor = Executors.newFixedThreadPool(10); //create a list to hold the Future object associated with Callable ListFutureString list = new ArrayListFutureString(); //Create MyCallable instance CallableString callable = new MyCallable(); for(int i=0; i 100; i++){ //submit Callable tasks to be executed by thread pool FutureString future = executor.submit(callable); //add Future to the list, we can get return value using Future list.add(future); } for(FutureString fut : list){ try { //print the return value of Future, notice the output delay in console // because Future.get() waits for task to get completed System.out.println(new Date()+ "::"+fut.get()); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } } //shut down the executor service now executor.shutdown(); }}Una vez que ejecutamos el programa anterior, notarás la demora en la salida porque el método get() de Java Future espera a que se complete la tarea invocable de Java. Observa también que solo hay 10 subprocesos ejecutando estas tareas. Aquí hay un fragmento de la salida del programa anterior.
Mon Dec 31 20:40:15 PST 2012::pool-1-thread-1Mon Dec 31 20:40:16 PST 2012::pool-1-thread-2Mon Dec 31 20:40:16 PST 2012::pool-1-thread-3Mon Dec 31 20:40:16 PST 2012::pool-1-thread-4Mon Dec 31 20:40:16 PST 2012::pool-1-thread-5Mon Dec 31 20:40:16 PST 2012::pool-1-thread-6Mon Dec 31 20:40:16 PST 2012::pool-1-thread-7Mon Dec 31 20:40:16 PST 2012::pool-1-thread-8Mon Dec 31 20:40:16 PST 2012::pool-1-thread-9Mon Dec 31 20:40:16 PST 2012::pool-1-thread-10Mon Dec 31 20:40:16 PST 2012::pool-1-thread-2...Consejo : ¿Qué sucede si queremos anular algunos de los métodos de la interfaz Future de Java? Por ejemplo, si queremos anular un get()método para que se agote el tiempo de espera después de un tiempo predeterminado en lugar de esperar indefinidamente, en este caso resulta útil la clase FutureTask de Java , que es la implementación base de la interfaz Future. Consulta el ejemplo FutureTask de Java para obtener más información sobre esta clase.