Servicios al ejecutor

Ejecutor

Executor es la interfaz base para clases que implementa el lanzamiento de tareas Runnable . Esto proporciona ayuda para agregar una tarea y cómo iniciarla.

ExecutorService es una interfaz que amplía las propiedades de Executor y que describe un servicio para ejecutar tareas Runnable o Callable . Los métodos de envío aceptan una tarea en forma de Callable o Runnable como entrada , y Future se usa como valor de retorno, a través del cual puede obtener el resultado.

El método invocarTodo se encarga de ejecutar tareas, devolviendo una lista de tareas con su estado y resultados de finalización.

El método invoqueAny es responsable de ejecutar tareas, devolviendo el resultado de una tarea completada con éxito (es decir, sin lanzar una excepción), si la hay.

ScheduledExecutorService : esta interfaz agrega la capacidad de ejecutar tareas pendientes con un cierto retraso o un cierto período.

AbstractExecutorService es una clase abstracta para construir un ExecutorService 'a. En el interior hay una implementación de los métodos submit , invocarTodos , invocarCualquiera . Esta clase hereda ThreadPoolExecutor , ScheduledThreadPoolExecutor y ForkJoinPool .

public static void main(String[] args) {
   ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
   Callable<String> task = () -> {
       System.out.println(Thread.currentThread().getName());
       return Thread.currentThread().getName();
   };
   scheduledExecutorService.schedule(task, 10, TimeUnit.SECONDS);
   scheduledExecutorService.shutdown();
}

ThreadPoolExecutor

Executors es una clase de fábrica para crear ThreadPoolExecutor , ScheduledThreadPoolExecutor . Si necesita crear uno de estos grupos, entonces esta fábrica es exactamente lo que necesita. Contiene diferentes adaptadores Runnable-Callable, PrivilegedAction-Callable, PrivilegedExceptionAction-Callable y otros. Tiene métodos estáticos para crear diferentes ThreadPool .

ThreadPoolExecutor : implementa las interfaces Executor y ExecutorService y separa la creación de tareas de la ejecución de tareas. Necesitamos implementar objetos Runnable y enviarlos al ejecutor, y ThreadPoolExecutor es responsable de su ejecución, creación de instancias y trabajo con hilos.

ScheduledThreadPoolExecutor : además de los métodos ThreadPoolExecutor , crea un conjunto de subprocesos que pueden programar comandos para ejecutarse después de un retraso determinado o para una ejecución periódica.

ThreadFactoryes un objeto que crea nuevos hilos a pedido. Necesitamos pasar una instancia al método Executors.newSingleThreadExecutor(ThreadFactory threadFactory) .

ExecutorService executorService = Executors.newSingleThreadExecutor(new ThreadFactory() {
 @Override public Thread newThread(Runnable r) {
Thread thread = new Thread(r, "MyThread");
thread.setPriority(Thread.MAX_PRIORITY);
 return thread; }
 });

RejectedExecutionHandler : le permite definir un controlador para tareas que, por algún motivo, no se pueden ejecutar a través de ThreadPoolExecutor . Esto sucede cuando no hay transmisiones gratuitas o el servicio se cierra o apaga.

Varias implementaciones estándar se encuentran en la clase ThreadPoolExecutor :

• CallerRunsPolicy: ejecuta una tarea en el subproceso de llamada;
• AbortPolicy: lanza una excepción;
• DiscardPolicy: ignora la tarea;
• DiscardOldestPolicy: elimina la tarea no iniciada más antigua de la cola y luego intenta agregar una nueva tarea nuevamente.

Servicio de finalización

CompletionService es una interfaz de servicio con desacoplamiento de iniciar tareas asincrónicas y obtener resultados. Para agregar tareas, hay un métodode envío, y para obtener los resultados de las tareas ya completadas, se utilizan un método de bloqueo detomade encuestasin bloqueo.

ExecutorCompletionService es un contenedor sobre cualquier clase que implemente la interfaz Executor , como ThreadPoolExecutor o ForkJoinPool . Se utiliza cuando es necesario abstraerse del método de lanzamiento de tareas y control de su ejecución.

Si hay tareas completadas, las retiramos. Si no hay tareas, nos quedamos esperando hasta que se complete algo. El servicio utiliza un LinkedBlockingQueue en su núcleo, pero puede pasar cualquier implementación de BlockingQueue.