El Ejecutor en el paquete java.util.concurrent de Java SE5 administrará el objeto Thread por usted, simplificando la programación concurrente. El ejecutor proporciona una capa indirecta entre el cliente y las tareas de ejecución, y el ejecutor realiza las tareas en lugar del cliente. Executor le permite administrar la ejecución de tareas asincrónicas sin tener que administrar explícitamente el ciclo de vida de los subprocesos. El método preferido para iniciar tareas cuando Executor está en Java SE5 / 6. Executor introduce algunas clases funcionales para administrar y usar thread Thread, incluido el grupo de thread, Executor, Executors, ExecutorService, CompletionService, Future, Callable, etc.
La interfaz Executor solo tiene un método de ejecución. La interfaz ExecutorService extiende Executor y agrega algunos métodos de administración del ciclo de vida, como shutdown (que puede evitar que se envíen nuevas tareas a este Executor, y el hilo actual continuará ejecutándose antes de que se llame a shutdown () Tarea), enviar, etc. El ciclo de vida de un ejecutor tiene tres estados, en ejecución, apagándose y terminando.
Crear un grupo de subprocesos La
clase Executors, proporciona una serie de métodos de fábrica para crear un grupo de subprocesos, el grupo de subprocesos devuelto implementa la interfaz ExecutorService.
Cree un grupo de subprocesos con un número fijo de subprocesos.
ExecutorService estático público newFixedThreadPool (int nThreads)
Cree un grupo de subprocesos almacenables en caché, la llamada a ejecutar reutilizará los subprocesos construidos previamente (si los subprocesos están disponibles). Si no hay ningún hilo existente disponible, se crea un nuevo hilo y se agrega al
grupo. Termine y elimine de la caché los subprocesos que no se hayan utilizado durante 60 segundos .
public static ExecutorService newCachedThreadPool ()
Crea un ejecutor de un solo subproceso. Para asegurarse de que solo se esté ejecutando una tarea en cualquier subproceso en cualquier momento. Es como un FixedThreadPool con un número de subprocesos de 1
ExecutorService público estático newSingleThreadExecutor ()
Cree un grupo de subprocesos que admita el tiempo y la ejecución de tareas periódicas. En la mayoría de los casos, se puede usar para reemplazar la clase Timer.
public static ScheduledExecutorService newScheduledThreadPool (int corePoolSize)
Interfaz ejecutable e interfaz
invocable Runnable es una tarea independiente de realizar el trabajo, pero (método run () ) no devuelve ningún valor.
En Java SE5 introdujo Callabel genérico, indica que el parámetro de tipo es un parámetro del proceso que tiene un tipo de valor de llamada () (en lugar de RUN ()) se devuelve, y debe ser el método ExcecutorService .submit () Llámalo.
import java.util.*;
import java.util.concurrent.*;
class TaskWithResult implements Callable<String>{
private int id;
public TaskWithResult(int id) {
this.id=id;
}
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return "result of TaskWithResult "+id;
}
}
public class CallableDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
ExecutorService exec=
Executors.newCachedThreadPool();
ArrayList<Future<String>> results=
new ArrayList<Future<String>>();
for(int i=0;i<10;i++) {
results.add(exec.submit(new TaskWithResult(i)));
}
for(Future<String> fs:results) {
try {
System.out.println(fs.get());
}catch(Exception e) {
e.printStackTrace();
}
}
}
}
/*
result of TaskWithResult 0
result of TaskWithResult 1
result of TaskWithResult 2
result of TaskWithResult 3
result of TaskWithResult 4
result of TaskWithResult 5
result of TaskWithResult 6
result of TaskWithResult 7
result of TaskWithResult 8
result of TaskWithResult 9
*/
El método submit () genera un objeto futuro, que se parametriza con el tipo específico de resultado devuelto por Callable.