Hoy voy hablar sobre la clase "
ExecutorService", con esta clase no permite gestionar un pool de hilos. A continuación pongo un ejemplo de uso de la clase con comentarios de cada uno de los ejemplos.
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Main {
private ExecutorService executor;
/**
*Clase para terminar todos los hilos
*/
private void endExecutor(){
executor.shutdown();
try
{
if (!executor.awaitTermination(60, TimeUnit.SECONDS))
{
executor.shutdownNow();
if (!executor.awaitTermination(60, TimeUnit.SECONDS))
{
System.err.println("executor no ha terminado");
}
}
} catch (InterruptedException ie) {
executor.shutdownNow();
Thread.currentThread().interrupt();
}
}
/**
* Crea un pool que va a ir creando threads conforme se vayan necesitando
* si hay threads libres, se ponen las tareas a procesarse dentro de dichos threads, y
* las tareas faltantes se procesan en threads nuevos
*/
public void newCachedThreadRool(){
this.executor = Executors.newCachedThreadPool();
for(int i=0; i < 5; i++){
this.executor.execute(new Handler("Hilo_"+i));
}
endExecutor();
}
/**
* crea un pool con el número de threads indicado; dichos threads siempre estarán listos
* para procesar tareas. El pool maneja también una cola de tareas; cada thread toma una
* tarea de la cola y la procesa, y al terminar toma otra tarea de la cola para procesarla, etc en un ciclo
*/
public void newFixedThreadPool(){
this.executor = Executors.newFixedThreadPool(3);
for(int i=0; i < 5; i++){
this.executor.execute(new Handler("Hilo_"+i));
}
endExecutor();
}
/**
* crea un pool de un solo thread, con una cola en donde se ponen las tareas a procesar;
* el thread toma una tarea de la cola, la procesa y toma la siguiente, en un ciclo.
*/
public void newSingleThreadExecutor(){
this.executor = Executors.newSingleThreadExecutor();
for(int i=0; i < 5; i++){
this.executor.execute(new Handler("Hilo_"+i));
}
endExecutor();
}
/**
* crea un pool que va a ejecutar tareas programadas cada cierto tiempo, ya sea una sola
* vez o de manera repetitiva. Es parecido a un timer, pero con la diferencia de que puede
* tener varios threads que irán realizando las tareas programadas conforme se desocupen.
* También hay una versión de un solo thread.
*/
public void newScheduledThreadPool(){
this.executor = Executors.newScheduledThreadPool(3);
for(int i=0; i < 5; i++){
this.executor.execute(new Handler("Hilo_"+i));
}
endExecutor();
}
/**
* Si queremos que despues de la excución nos devuelva algo tenemos que implemetar la
* interfaz Callabe
*/
public void callableThread() throws ExecutionException, InterruptedException{
this.executor = Executors.newCachedThreadPool();
Collection callableResults = new HashSet();
for(int i=0; i < 3; i++){
callableResults.add(new CallableResult("Callable_"+i));
}
//solo uno
Future future = executor.submit((CallableResult)callableResults.toArray()[0]);
//devuelve el resultado de una tare completa correcamente
String result = executor.invokeAny(callableResults);
//Espera a que se termine todos los hilos
List<"Future"> futures = executor.invokeAll(callableResults);
System.out.println("future.get() = " + future.get());
System.out.println("Result invoke any = " + result);
for(int i=0; i < futures.size(); i++){
System.out.println("Result invoke all = " + futures.get(i).get());
}
}
public static void main(String[] args) {
try
{
System.out.println("El numero de procesadores : "+Runtime.getRuntime().availableProcessors());
new Main().callableThread();
}catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
Cuando copies el código teneies que citar la comillas doble Future porque no me daba un error el editor de html.
A continuación la clase Handler
import java.util.Random;
public class Handler implements Runnable {
private String nombreHilo;
private Random generador;
private int dormir;
public Handler(String name) {
this.nombreHilo = name;
this.generador = new Random();
this.dormir = generador.nextInt(5000);
}
public void run() {
try
{
System.out.println("\t Voy a dormir "+this.dormir+" : "+nombreHilo);
Thread.sleep(this.dormir);
}
catch (InterruptedException exception) {
exception.printStackTrace();
}
System.out.println("\t Ya he terminado de dormir : "+nombreHilo);
}
}
public static void main(String[] args) {
try
{
System.out.println("El numero de procesadores : "+Runtime.getRuntime().availableProcessors());
new Main().callableThread();
}catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
Y por ultimo la clase CallableResult
import java.util.Random;
import java.util.concurrent.Callable;
public class CallableResult implements Callable{
private String nombreHilo;
private Random generador;
private int dormir;
public CallableResult(String name) {
this.nombreHilo = name;
this.generador = new Random();
this.dormir = generador.nextInt(5000);
}
public String call() throws Exception {
try
{
System.out.println("\t Voy a dormir "+this.dormir+" : "+nombreHilo);
Thread.sleep(this.dormir);
System.out.println("\t Ya he terminado de dormir : "+nombreHilo);
return "terminado "+nombreHilo;
}
catch (InterruptedException exception) {
return exception.getMessage();
}
}
}
Con esto es todo sobre la clase ExecutorService
