Comment attendre la fin d'un certain nombre de threads ?

Question

Quel est le moyen d'attendre simplement la fin de tous les processus threadés ? Par exemple, disons que j'ai :

public class DoSomethingInAThread implements Runnable{

    public static void main(String[] args) {
        for (int n=0; n<1000; n++) {
            Thread t = new Thread(new DoSomethingInAThread());
            t.start();
        }
        // wait for all threads' run() methods to complete before continuing
    }

    public void run() {
        // do something here
    }

}

Comment puis-je modifier cela pour que le main() La méthode s'arrête au commentaire jusqu'à ce que tous les fils de discussion run() sortie des méthodes ? Merci !

Answer 1

Vous mettez tous les fils dans un tableau, vous les démarrez tous, puis vous avez une boucle

for(i = 0; i < threads.length; i++)
  threads[i].join();

Chaque jointure se bloquera jusqu'à ce que le fil d'exécution respectif soit terminé. Les threads peuvent se terminer dans un ordre différent de celui dans lequel vous les avez joints, mais ce n'est pas un problème : lorsque la boucle sort, tous les threads sont terminés.

Answer 2

Un moyen serait de faire un List de Thread s, créer et lancer chaque thread, tout en l'ajoutant à la liste. Une fois que tout est lancé, bouclez à nouveau dans la liste et appelez join() sur chacun d'eux. L'ordre d'exécution des threads n'a pas d'importance, tout ce que vous devez savoir, c'est qu'au moment où la deuxième boucle termine son exécution, tous les threads auront terminé.

Une meilleure approche consiste à utiliser un ExecutorService et ses méthodes associées :

List<Callable> callables = ... // assemble list of Callables here
                               // Like Runnable but can return a value
ExecutorService execSvc = Executors.newCachedThreadPool();
List<Future<?>> results = execSvc.invokeAll(callables);
// Note: You may not care about the return values, in which case don't
//       bother saving them

L'utilisation d'un ExecutorService (et toutes les nouveautés de Java 5) utilitaires de concurrence ) est incroyablement flexible, et l'exemple ci-dessus ne fait qu'effleurer la surface.

Answer 3

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class DoSomethingInAThread implements Runnable
{
   public static void main(String[] args) throws ExecutionException, InterruptedException
   {
      //limit the number of actual threads
      int poolSize = 10;
      ExecutorService service = Executors.newFixedThreadPool(poolSize);
      List<Future<Runnable>> futures = new ArrayList<Future<Runnable>>();

      for (int n = 0; n < 1000; n++)
      {
         Future f = service.submit(new DoSomethingInAThread());
         futures.add(f);
      }

      // wait for all tasks to complete before continuing
      for (Future<Runnable> f : futures)
      {
         f.get();
      }

      //shut down the executor service so that this thread can exit
      service.shutdownNow();
   }

   public void run()
   {
      // do something here
   }
}

Answer 4

Évitez complètement la classe Thread et utilisez plutôt les abstractions supérieures fournies par java.util.concurrent.

La classe ExecutorService fournit le méthode invokeAll qui semble faire exactement ce que vous voulez.

Answer 5

Si vous faites une liste des fils, vous pouvez les parcourir en boucle et .join() contre chacun d'eux, et votre boucle se terminera lorsque tous les fils l'auront fait. Je ne l'ai pas encore essayé.

[http://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html#join()](http://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html#join())