Qual è l'equivalente java di AggregateException da .net?

Question

In .net la classe AggregateException consente di generare un'eccezione contenente più eccezioni.

Ad esempio, si vorrebbe lanciare un AggregateException se si eseguono più attività in parallelo e alcune di esse non sono riuscite con eccezioni.

java ha una classe equivalente?

Il caso specifico che voglio utilizzare in:

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

Non sono a conoscenza di classi incorporate o librerie, come non ho mai pensato di voler fare prima (in genere si limitano le eccezioni), ma non sarebbe così difficile scrivi te stesso

si sarebbe probabilmente desidera scegliere una delle eccezioni di essere "primario" in modo che possa essere utilizzato per riempire stacktraces, ecc

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

io non vedo proprio il motivo per cui si dovrebbe usare le eccezioni, in primo luogo per contrassegnare le attività come incompleta/fallito, ma in ogni caso, è shouldn essere difficile crearne uno da solo Hai qualche codice da condividere in modo che possiamo aiutarti con una risposta più specifica?

Answer 3

È possibile rappresentare Taska multipla come

List<Callable<T>> tasks 

Poi, se si desidera che il computer per loro fare attualmente in uso in parallelo

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

Ora è possibile iterare attraverso i risultati.

Quindi realCause (se esiste) è l'eccezione che viene generata nell'attività associata.

Answer 4

Java 7 del Throwable.addSuppressed(Throwable) farà qualcosa di simile, anche se è stato costruito per uno scopo leggermente diverso (try-with-resource)