Prochains appels de tâche asynchrone suspendus alors qu'une exception se produit

Question

J'ai écrit de nombreux appels de tâches asynchrones futurs les uns au-dessous des autres dans mon programme Java. Donner un exemple ci-dessous

FutureTask<List<ConditionFact>> x = getConditionFacts(final Member member); 
FutureTask<List<RiskFact>> x = getRiskFacts(final Member member); 
FutureTask<List<SAEFact>> x = getSAEFacts(final Member member); 

Supposons maintenant que je crée délibérément une exception dans le second appel ci-dessus et joindre tous les 3 appels get() à l'intérieur d'un bloc try/catch Je ne vois pas l'exception à venir pour attraper bloc et mon programme java est toujours immobile. Tous les 3 appels de méthode se produisent simultanément. Mais si je joins chacun des get() dans des blocs catch distincts, je suis capable de les attraper. Pourquoi? Aussi, au moment où je commence à enfermer chaque méthode get() dans les blocs try try je perds le multi-threading. Les appels de méthode se passe un par un code

 FutureTask<List<ConditionFact>> task = getConditionFacts(member); 
    // wait for the task to complete and get the result: 
    try { 
     List<ConditionFact> conditionFacts = task.get(); 
    } 
    catch (ExecutionException e) { 
     // an exception occurred. 
     Throwable cause = e.getCause(); // cause is the original exception thrown by the DAO 
    } 
    FutureTask<List<ConditionFact>> task = getRiskFacts(member); 
    // wait for the task to complete and get the result: 
    try { 
     List<RiskFact> conditionFacts = task.get(); 
    } 
    catch (ExecutionException e) { 
     // an exception occurred. 
     Throwable cause = e.getCause(); // cause is the original exception thrown by the DAO 
    } 

quand je suis en mesure d'attraper l'exception que je suis en train de perdre multithreading et quand je suis en mesure de reproduire multi threads je perds l'exception.

Toute idée comment gérer exception individuellement et permettent d'atteindre multithreading aussi en même temps

Answer 1

J'étais vraiment sur ce point. La bonne réponse consiste à utiliser un ExecutorService pour exécuter les tâches dans un pool de threads.

ExecutorService executor = Executor.newFixedThreadPool(2); 
FutureTask<List<ConditionFact>> task1 = getConditionFacts(member); 
FutureTask<List<ConditionFact>> task2 = getRiskFacts(member); 
executor.execute(task1); 
executor.execute(task2); 
// wait for the task to complete and get the result: 
try { 
    List<ConditionFact> conditionFacts = task1.get(); 
} 
catch (ExecutionException e) { 
    // an exception occurred. 
    Throwable cause = e.getCause(); // cause is the original exception thrown by the DAO 
} 
// wait for the task to complete and get the result: 
try { 
    List<RiskFact> conditionFacts = task2.get(); 
} 
catch (ExecutionException e) { 
    // an exception occurred. 
    Throwable cause = e.getCause(); // cause is the original exception thrown by the DAO 
} 

Cela résoudra le problème d'exécution à un seul thread. J'ai la réponse ici: http://programmingexamples.wikidot.com/futuretask

Answer 2

Le ExecutorCompletionService devrait aider à résoudre vos problèmes. Votre code a besoin d'un mécanisme de file d'attente à implémenter pour gérer les résultats et le service ExecutorCompletionService devrait vous aider. Vérifiez-le.