attendre jusqu'à ce que tous les threads terminer leur travail en java

Question

Je suis en train d'écrire une application qui dispose de 5 threads obtenir des informations à partir du web simultanément et de remplir 5 domaines différents dans une classe de mémoire tampon.
J'ai besoin de valider des tampons de données et de les stocker dans une base de données, lorsque tous les threads terminé leur travail.
Comment puis-je faire cela (soyez alerté lorsque tous les threads terminé leur travail) ?

Answer 1

Ma méthode consiste à utiliser un ExecutorService à gérer des pools de threads.

ExecutorService es = Executors.newCachedThreadPool();
for(int i=0;i<5;i++)
    es.execute(new Runnable() { /*  your task */ });
es.shutdown();
boolean finshed = es.awaitTermination(1, TimeUnit.MINUTES);
// all tasks have finished or the time has been reached.

Answer 2

Vous pouvez join pour les threads. La jointure des blocs jusqu'à ce que le thread se termine.

for (Thread thread : threads) {
    thread.join();
}

Notez que join jette un InterruptedException. Vous aurez à décider quoi faire si cela se produit (par exemple, essayez d'annuler les autres threads pour éviter le travail inutile en cours).

Answer 3

Hormis Thread.join() suggéré par d'autres, java 5 introduit l'exécuteur cadre. Là, vous ne travaillez pas avec des Thread objets. Au lieu de cela, vous soumettez votre Callable ou Runnable objets à un exécuteur testamentaire. Il y a un exécuteur, qui est destinée à exécuter des tâches multiples et à la restitution de leurs résultats de la commande. C'est l' ExecutorCompletionService:

ExecutorCompletionService executor;
for (..) {
    executor.submit(Executors.callable(yourRunnable));
}

Ensuite, vous pouvez appeler à plusieurs reprises take() jusqu'à ce qu'il n'y a pas plus d' Future<?> objets de retour, ce qui signifie que tous d'entre eux sont terminés.

---

Une autre chose qui peut être, en fonction de votre scénario est - CyclicBarrier.

Une synchronisation de l'aide qui permet à un ensemble de threads à tous d'attendre les uns des autres, pour arriver à une barrière point. CyclicBarriers sont utiles dans les programmes impliquant un fixe de taille moyenne partie de threads qui doivent parfois attendre les uns des autres. La barrière est appelé cyclique, car il peut être ré-utilisées après les threads en attente sont libérés.

Answer 4

Une autre possibilité est l' CountDownLatch de l'objet, ce qui est utile pour les situations simples : puisque vous connaissez à l'avance le nombre de threads, vous l'initialiser avec le comte, et de passer la référence de l'objet à chaque thread.
Après la réalisation de sa tâche, chaque thread appelle CountDownLatch.countDown() qui décrémente le compteur interne. Le thread principal, après le départ de tous les autres, doit faire l' CountDownLatch.await() de blocage d'appel. Il sera publié dès que le compteur interne a atteint 0.

Attention, avec cet objet, une InterruptedException peut être jeté ainsi.

Answer 5

Vous n'

for (Thread t : new Thread[] { th1, th2, th3, th4, th5 })
    t.join()

Après cette boucle, vous pouvez être sûr que tous les threads ont fini leur travail.