Código de ejemplo para devolver tres tipos de excepciones.
import java.util.concurrent.*;
import java.util.*;
public class ExceptionDemo{
public static void main(String args[]){
int poolSize=1;
int maxPoolSize=1;
int queueSize=30;
long aliveTive=60;
ArrayBlockingQueue<Runnable> queue= new ArrayBlockingQueue<Runnable>(queueSize);
ThreadPoolExecutor executor= new ThreadPoolExecutor(poolSize,maxPoolSize,aliveTive,
TimeUnit.MILLISECONDS,queue);
List<Future> futures = new ArrayList<Future>();
for (int i=0; i < 5; i++){
futures.add(executor.submit(new RunnableEx()));
}
for (Iterator it = futures.iterator(); it.hasNext();){
try {
Future f = (Future)it.next();
f.get(4000,TimeUnit.MILLISECONDS);
}catch(TimeoutException terr){
System.out.println("Timeout exception");
terr.printStackTrace();
}
catch(InterruptedException ierr){
System.out.println("Interrupted exception:");
ierr.printStackTrace();
}catch(ExecutionException err){
System.out.println("Exeuction exception:");
err.printStackTrace();
Thread.currentThread().interrupt();
}
}
executor.shutdown();
}
}
class RunnableEx implements Runnable{
public void run() {
// code in here
System.out.println("Thread name:"+Thread.currentThread().getName());
try{
Random r = new Random();
if (r.nextInt(2) == 1){
Thread.sleep(2000);
}else{
Thread.sleep(4000);
}
System.out.println("eee:"+1/0);
}catch(InterruptedException irr){
irr.printStackTrace();
}
}
}
de salida:
Thread name:pool-1-thread-1
Timeout exception
Thread name:pool-1-thread-1
java.util.concurrent.TimeoutException
at java.util.concurrent.FutureTask.get(FutureTask.java:201)
at ExceptionDemo.main(ExceptionDemo.java:20)
Thread name:pool-1-thread-1
Exeuction exception:
java.util.concurrent.ExecutionException: java.lang.ArithmeticException:/by zero
at java.util.concurrent.FutureTask.report(FutureTask.java:122)
at java.util.concurrent.FutureTask.get(FutureTask.java:202)
at ExceptionDemo.main(ExceptionDemo.java:20)
Caused by: java.lang.ArithmeticException:/by zero
at RunnableEx.run(ExceptionDemo.java:49)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471)
at java.util.concurrent.FutureTask.run(FutureTask.java:262)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
at java.lang.Thread.run(Thread.java:744)
Interrupted exception:
java.lang.InterruptedException
at java.util.concurrent.FutureTask.awaitDone(FutureTask.java:400)
at java.util.concurrent.FutureTask.get(FutureTask.java:199)
at ExceptionDemo.main(ExceptionDemo.java:20)
Timeout exception
java.util.concurrent.TimeoutException
at java.util.concurrent.FutureTask.get(FutureTask.java:201)
Thread name:pool-1-thread-1
at ExceptionDemo.main(ExceptionDemo.java:20)
Thread name:pool-1-thread-1
Timeout exception
java.util.concurrent.TimeoutException
at java.util.concurrent.FutureTask.get(FutureTask.java:201)
at ExceptionDemo.main(ExceptionDemo.java:20)
TimeoutException: Excepción lanzada cuando un bloqueo de los tiempos de operación a cabo.
En el ejemplo anterior, algunas tareas están tomando más tiempo (debido a 4 segundos del sueño) y bloqueando el funcionamiento de get()
en Future
Cualquiera de aumentar el tiempo de espera u optimizar tarea Ejecutable.
ExecutionException: excepción lanzada al intentar recuperar el resultado de una tarea que abortada por lanzar una excepción => El cálculo produjo una excepción
En el ejemplo anterior, esta Exception
se simula a través de ArithmeticException:/by zero
Generalmente, deberías atraparlo, corrige la causa raíz si es trivial, como se cita en el ejemplo.
InterruptedException: Lanzado cuando un hilo está esperando, durmiendo u ocupado de otra manera, y el hilo se interrumpe, ya sea antes o durante la actividad.
En el ejemplo anterior, este Exception
se simula al interrumpir el hilo actual durante ExecutionException
.
En general, debe atraparlo no actuar en consecuencia.
Hay una manera de evitar que ExecutionException arroje, cuando hay una excepción en el procesamiento de una tarea. Incluso si capturó la Excepción arroja el procesamiento y lo maneja, todavía ajusta la excepción a ExecutionException y lo arroja al get. –
Existe una relación entre InterruptedException y ExecutionException, solo para saber cuál capturar primero. En la pregunta de SO capta la excepción InterruptedException primero y luego la ExecutionException. ¿El comportamiento será el mismo si cambiamos el orden? – prime
@prime: ver https://stackoverflow.com/a/10964899/217324. Ambas excepciones se extienden Excepción, ninguna es más específica que la otra. El orden no importa en este caso. –