attendez que tous les threads aient terminé leur travail en java

J'écris une application qui a 5 threads qui obtiennent des informations du Web simultanément et remplissent 5 champs différents dans une classe de tampon.
J'ai besoin de valider les données du tampon et de les stocker dans une base de données lorsque tous les threads ont terminé leur travail.
Comment puis-je faire cela (être alerté lorsque tous les threads ont terminé leur travail)?

L'approche que j'adopte consiste à utiliser un ExecutorService pour 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 finished = es.awaitTermination(1, TimeUnit.MINUTES);
// all tasks have finished or the time has been reached.

Vous pouvez joinles fils. La jointure se bloque jusqu'à ce que le thread se termine.

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

Notez que joinjette un InterruptedException. Vous devrez décider quoi faire si cela se produit (par exemple, essayez d'annuler les autres threads pour éviter un travail inutile).

Jetez un œil à diverses solutions.

1. join()L'API a été introduite dans les premières versions de Java. Certaines bonnes alternatives sont disponibles avec ce package simultané depuis la version JDK 1.5.

2. ExecutorService # invokeAll ()

   Exécute les tâches données, renvoyant une liste de Futures conservant leur statut et leurs résultats lorsque tout est terminé.

   Reportez-vous à cette question SE associée pour un exemple de code:

   Comment utiliser invokeAll () pour laisser tous les pools de threads faire leur tâche?

3. CountDownLatch

   Aide à la synchronisation qui permet à un ou plusieurs threads d'attendre la fin d'un ensemble d'opérations en cours d'exécution dans d'autres threads.

   Un CountDownLatch est initialisé avec un nombre donné. Les méthodes d'attente se bloquent jusqu'à ce que le nombre actuel atteigne zéro en raison des appels de la countDown()méthode, après quoi tous les threads en attente sont libérés et toutes les invocations ultérieures de wait sont immédiatement renvoyées. Il s'agit d'un phénomène ponctuel - le décompte ne peut pas être réinitialisé. Si vous avez besoin d'une version qui réinitialise le nombre, envisagez d'utiliser un CyclicBarrier .

   Reportez-vous à cette question pour l'utilisation de CountDownLatch

   Comment attendre un thread qui génère son propre thread?

4. ForkJoinPool ou newWorkStealingPool () dans les exécuteurs

5. Parcourez tous les objets Future créés après avoir été soumis àExecutorService

Mis à part Thread.join()suggéré par d'autres, java 5 a introduit le framework exécuteur. Là, vous ne travaillez pas avec des Threadobjets. Au lieu de cela, vous soumettez vos objets Callableou Runnableà un exécuteur testamentaire. Il existe un exécuteur spécial destiné à exécuter plusieurs tâches et à renvoyer leurs résultats dans le désordre. C'est ça ExecutorCompletionService:

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

Ensuite, vous pouvez appeler à plusieurs reprises take()jusqu'à ce qu'il n'y ait plus d' Future<?>objets à renvoyer, ce qui signifie qu'ils sont tous terminés.

Une autre chose qui peut être pertinente, selon votre scénario est CyclicBarrier.

Une aide à la synchronisation qui permet à un ensemble de threads d'attendre l'un l'autre pour atteindre un point de barrière commun. Les CyclicBarriers sont utiles dans les programmes impliquant un groupe de threads de taille fixe qui doivent parfois attendre les uns les autres. La barrière est appelée cyclique car elle peut être réutilisée après la libération des threads en attente.

Une autre possibilité est l' CountDownLatchobjet, qui est utile pour des situations simples: puisque vous connaissez à l'avance le nombre de threads, vous l'initialisez avec le décompte pertinent, et passez la référence de l'objet à chaque thread.
À la fin de sa tâche, chaque thread appelle CountDownLatch.countDown()ce qui décrémente le compteur interne. Le thread principal, après avoir démarré tous les autres, doit faire l' CountDownLatch.await()appel de blocage. Il sera libéré dès que le compteur interne aura atteint 0.

Faites attention qu'avec cet objet, un InterruptedExceptionpeut également être lancé.

Tu fais

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

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

Attendez / bloquez le fil principal jusqu'à ce que d'autres threads aient terminé leur travail.

Comme @Ravindra babudit, cela peut être réalisé de différentes manières, mais en montrant des exemples.

• java.lang.Thread. join () ^{Depuis: 1.0}

  public static void joiningThreads() throws InterruptedException {
      Thread t1 = new Thread( new LatchTask(1, null), "T1" );
      Thread t2 = new Thread( new LatchTask(7, null), "T2" );
      Thread t3 = new Thread( new LatchTask(5, null), "T3" );
      Thread t4 = new Thread( new LatchTask(2, null), "T4" );
  
      // Start all the threads
      t1.start();
      t2.start();
      t3.start();
      t4.start();
  
      // Wait till all threads completes
      t1.join();
      t2.join();
      t3.join();
      t4.join();
  }
  

• java.util.concurrent.CountDownLatch ^{depuis: 1.5}

  • .countDown() «Décrémente le nombre du groupe de verrouillage.
  • .await() «Les méthodes d'attente se bloquent jusqu'à ce que le décompte actuel atteigne zéro.

  Si vous avez créé, latchGroupCount = 4alors countDown()devrait être appelé 4 fois pour faire le compte 0. Donc, cela await()libérera les threads de blocage.

  public static void latchThreads() throws InterruptedException {
      int latchGroupCount = 4;
      CountDownLatch latch = new CountDownLatch(latchGroupCount);
      Thread t1 = new Thread( new LatchTask(1, latch), "T1" );
      Thread t2 = new Thread( new LatchTask(7, latch), "T2" );
      Thread t3 = new Thread( new LatchTask(5, latch), "T3" );
      Thread t4 = new Thread( new LatchTask(2, latch), "T4" );
  
      t1.start();
      t2.start();
      t3.start();
      t4.start();
  
      //latch.countDown();
  
      latch.await(); // block until latchGroupCount is 0.
  }
  

Exemple de code de classe Threaded LatchTask. Pour tester l'utilisation de l'approche joiningThreads(); et latchThreads();de la méthode principale.

class LatchTask extends Thread {
    CountDownLatch latch;
    int iterations = 10;
    public LatchTask(int iterations, CountDownLatch latch) {
        this.iterations = iterations;
        this.latch = latch;
    }

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        System.out.println(threadName + " : Started Task...");

        for (int i = 0; i < iterations; i++) {
            System.out.println(threadName + " : " + i);
            MainThread_Wait_TillWorkerThreadsComplete.sleep(1);
        }
        System.out.println(threadName + " : Completed Task");
        // countDown() « Decrements the count of the latch group.
        if(latch != null)
            latch.countDown();
    }
}

• CyclicBarriers Une aide à la synchronisation qui permet à un ensemble de threads de s'attendre tous les uns les autres pour atteindre un point de barrière commun. Les CyclicBarriers sont utiles dans les programmes impliquant une partie de threads de taille fixe qui doivent parfois attendre les uns les autres. La barrière est appelée cyclique car elle peut être réutilisée après la libération des threads en attente.

  CyclicBarrier barrier = new CyclicBarrier(3);
  barrier.await();
  

  Par exemple, référez-vous à cette classe Concurrent_ParallelNotifyies .

• Framework Executer: nous pouvons utiliser ExecutorService pour créer un pool de threads et suivre la progression des tâches asynchrones avec Future.

  • submit(Runnable), submit(Callable)qui renvoient Future Object. En utilisant la future.get()fonction, nous pouvons bloquer le thread principal jusqu'à ce que les threads de travail terminent leur travail.

  • invokeAll(...) - retourne une liste d'objets Future via laquelle vous pouvez obtenir les résultats des exécutions de chaque Callable.

Trouvez un exemple d'utilisation d'Interfaces Runnable, Callable with Executor Framework.

@Voir également

• Découvrir que le fil est toujours en vie?

Stockez les objets Thread dans une collection (comme une liste ou un ensemble), puis parcourez la collection une fois que les threads sont démarrés et appelez join () sur les threads.

Vous pouvez utiliser la méthode Threadf # join à cet effet.

Bien que cela ne concerne pas le problème d'OP, si vous êtes intéressé par la synchronisation (plus précisément, un rendez-vous) avec exactement un thread, vous pouvez utiliser un échangeur

Dans mon cas, j'avais besoin de mettre en pause le thread parent jusqu'à ce que le thread enfant fasse quelque chose, par exemple acheva son initialisation. Un CountDownLatch fonctionne également bien.

Un service exécuteur peut être utilisé pour gérer plusieurs threads, y compris l'état et l'achèvement. Voir http://programmingexamples.wikidot.com/executorservice

essayez ceci, fonctionnera.

  Thread[] threads = new Thread[10];

  List<Thread> allThreads = new ArrayList<Thread>();

  for(Thread thread : threads){

        if(null != thread){

              if(thread.isAlive()){

                    allThreads.add(thread);

              }

        }

  }

  while(!allThreads.isEmpty()){

        Iterator<Thread> ite = allThreads.iterator();

        while(ite.hasNext()){

              Thread thread = ite.next();

              if(!thread.isAlive()){

                   ite.remove();
              }

        }

   }

J'ai eu un problème similaire et j'ai fini par utiliser Java 8 parallelStream.

requestList.parallelStream().forEach(req -> makeRequest(req));

C'est super simple et lisible. Dans les coulisses, il utilise le pool de jointure fork de la JVM par défaut, ce qui signifie qu'il attendra que tous les threads se terminent avant de continuer. Pour mon cas, c'était une solution intéressante, car c'était le seul parallelStream de mon application. Si vous avez plus d'un parallelStream en cours d'exécution simultanément, veuillez lire le lien ci-dessous.

Plus d'informations sur les flux parallèles ici .

Les réponses existantes ont dit pourrait join()chaque fil.

Mais il existe plusieurs façons d'obtenir le tableau / la liste des threads:

• Ajoutez le fil dans une liste lors de la création.
• Utilisez ThreadGrouppour gérer les threads.

Le code suivant utilisera l' ThreadGruopapproche. Il crée d'abord un groupe, puis lors de la création de chaque thread, spécifiez le groupe dans le constructeur, plus tard pourrait obtenir le tableau de thread viaThreadGroup.enumerate()

Code

SyncBlockLearn.java

import org.testng.Assert;
import org.testng.annotations.Test;

/**
 * synchronized block - learn,
 *
 * @author eric
 * @date Apr 20, 2015 1:37:11 PM
 */
public class SyncBlockLearn {
    private static final int TD_COUNT = 5; // thread count
    private static final int ROUND_PER_THREAD = 100; // round for each thread,
    private static final long INC_DELAY = 10; // delay of each increase,

    // sync block test,
    @Test
    public void syncBlockTest() throws InterruptedException {
        Counter ct = new Counter();
        ThreadGroup tg = new ThreadGroup("runner");

        for (int i = 0; i < TD_COUNT; i++) {
            new Thread(tg, ct, "t-" + i).start();
        }

        Thread[] tArr = new Thread[TD_COUNT];
        tg.enumerate(tArr); // get threads,

        // wait all runner to finish,
        for (Thread t : tArr) {
            t.join();
        }

        System.out.printf("\nfinal count: %d\n", ct.getCount());
        Assert.assertEquals(ct.getCount(), TD_COUNT * ROUND_PER_THREAD);
    }

    static class Counter implements Runnable {
        private final Object lkOn = new Object(); // the object to lock on,
        private int count = 0;

        @Override
        public void run() {
            System.out.printf("[%s] begin\n", Thread.currentThread().getName());

            for (int i = 0; i < ROUND_PER_THREAD; i++) {
                synchronized (lkOn) {
                    System.out.printf("[%s] [%d] inc to: %d\n", Thread.currentThread().getName(), i, ++count);
                }
                try {
                    Thread.sleep(INC_DELAY); // wait a while,
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.printf("[%s] end\n", Thread.currentThread().getName());
        }

        public int getCount() {
            return count;
        }
    }
}

Le thread principal attendra que tous les threads du groupe se terminent.

J'ai créé une petite méthode d'aide pour attendre la fin de quelques threads:

public static void waitForThreadsToFinish(Thread... threads) {
        try {
            for (Thread thread : threads) {
                thread.join();
            }
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

Utilisez ceci dans votre thread principal: while (! Executor.isTerminated ()); Mettez cette ligne de code après avoir démarré tous les threads du service exécuteur. Cela ne démarrera le thread principal qu'une fois tous les threads démarrés par les exécuteurs terminés. Assurez-vous d'appeler executor.shutdown (); avant la boucle ci-dessus.