¿Cuál es el equivalente de Java de AggregateException de .net?

Question

En .net, la clase AggregateException le permite lanzar una excepción que contiene múltiples excepciones.

Por ejemplo, le gustaría arrojar una excepción agregada si ejecutó varias tareas en paralelo y algunas de ellas fallaron con excepciones.

¿Java tiene una clase equivalente?

El caso específico quiero utilizarlo en:

public static void runMultipleThenJoin(Runnable... jobs) { 
    final List<Exception> errors = new Vector<Exception>(); 
    try { 
     //create exception-handling thread jobs for each job 
     List<Thread> threads = new ArrayList<Thread>(); 
     for (final Runnable job : jobs) 
      threads.add(new Thread(new Runnable() {public void run() { 
       try { 
        job.run(); 
       } catch (Exception ex) { 
        errors.add(ex); 
       } 
      }})); 

     //start all 
     for (Thread t : threads) 
      t.start(); 

     //join all 
     for (Thread t : threads) 
      t.join();    
    } catch (InterruptedException ex) { 
     //no way to recover from this situation 
     throw new RuntimeException(ex); 
    } 

    if (errors.size() > 0) 
     throw new AggregateException(errors); 
} 

Answer 1

No conozco ninguna clase incorporada o de biblioteca, ya que nunca antes había querido hacer esto antes (por lo general, simplemente cadenas las excepciones), pero no sería tan difícil escribete a ti mismo

Usted probablemente querrá escoger una de las excepciones a ser "primaria" por lo que se puede utilizar para rellenar stacktraces, etc.

public class AggregateException extends Exception { 

    private final Exception[] secondaryExceptions; 

    public AggregateException(String message, Exception primary, Exception... others) { 
     super(message, primary); 
     this.secondaryExceptions = others == null ? new Exception[0] : others; 
    } 

    public Throwable[] getAllExceptions() { 

     int start = 0; 
     int size = secondaryExceptions.length; 
     final Throwable primary = getCause(); 
     if (primary != null) { 
      start = 1; 
      size++; 
     } 

     Throwable[] all = new Exception[size]; 

     if (primary != null) { 
      all[0] = primary; 
     } 

     Arrays.fill(all, start, all.length, secondaryExceptions); 
     return all; 
    } 

} 

Answer 2

Realmente no veo por qué debería utilizar excepciones en el primer lugar para marcar tareas como incompleta/no, pero en cualquier caso, shouldn No será difícil crear uno tú mismo. ¿Tienes algún código para compartir para que podamos ayudarte con una respuesta más específica?

Answer 3

Puede representar múltiples taska como

List<Callable<T>> tasks 

Entonces, si desea que el equipo para realmente ellos lo hacen en el uso paralelo

ExecutorService executorService = .. initialize executor Service 
List<Future<T>> results = executorService.invokeAll () ; 

Ahora se puede repetir a través de los resultados.

try 
{ 
    T val = result . get () ; 
} 
catch (InterruptedException cause) 
{ 
    // this is not the exception you are looking for 
} 
catch (ExecutionExeception cause) 
{ 
    Throwable realCause = cause . getCause () // this is the exception you are looking for 
} 

Así realCause (si existe) es cualquier excepción de lo arrojado en su tarea asociada.

Answer 4

Java 7 de Throwable.addSuppressed(Throwable) va a hacer algo similar, aunque fue construido para un propósito ligeramente diferente (try-with-resource)