Comment attendre un nombre de threads à remplir?

Vous mettez tous les threads d'un tableau, à commencer tous, et ensuite une boucle

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

Chaque jointure bloc respectifs jusqu'à ce que le thread est terminé. Les Threads peuvent remplir dans un ordre différent de vous joindre à eux, mais ce n'est pas un problème: quand la boucle s'arrête, tous les threads sont terminés.

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
   }
}

au lieu de join(), qui est une ancienne API, vous pouvez utiliser CountDownLatch. J'ai modifié le code comme ci-dessous pour répondre à votre exigence.

import java.util.concurrent.*;
class DoSomethingInAThread implements Runnable{
    CountDownLatch latch;
    public DoSomethingInAThread(CountDownLatch latch){
        this.latch = latch;
    } 
    public void run() {
        try{
            System.out.println("Do some thing");
            latch.countDown();
        }catch(Exception err){
            err.printStackTrace();
        }
    }
}

public class CountDownLatchDemo {
    public static void main(String[] args) {
        try{
            CountDownLatch latch = new CountDownLatch(1000);
            for (int n=0; n<1000; n++) {
                Thread t = new Thread(new DoSomethingInAThread(latch));
                t.start();
            }
            latch.await();
            System.out.println("In Main thread after completion of 1000 threads");
        }catch(Exception err){
            err.printStackTrace();
        }
    }
}

Explication:

1. CountDownLatch a été initialisé avec le comte de 1000 selon votre condition.

2. Chaque thread de travail DoSomethingInAThread va décrémenter la CountDownLatch, qui a été adoptée dans le constructeur.

3. Thread principal CountDownLatchDemo await() jusqu'le comte est devenu zéro. Une fois que le comte est devenu zéro, vous obtiendrez en dessous de la ligne de sortie.

   In Main thread after completion of 1000 threads

Plus d'infos à partir de la documentation d'oracle page

public void await()
           throws InterruptedException

Le thread actuel à attendre jusqu'à ce que le loquet a compté à zéro, à moins que le thread est interrompu.

Veuillez vous reporter à la question SE pour d'autres options:

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

Envisager d'utiliser java.util.concurrent.CountDownLatch. Exemples dans la documentation javadoc

Si vous faites une liste des threads, vous pouvez faire une boucle à travers eux et .join() sur chaque, et la boucle sera fini lorsque tous les threads ont. Je n'ai pas essayé si.

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

Créer le thread de l'objet à l'intérieur de la première boucle for.

for (int i = 0; i < threads.length; i++) {
     threads[i] = new Thread(new Runnable() {
         public void run() {
             //some code to run in parallel
         }
     });
     threads[i].start();
 }

Et puis si ce que tout le monde ici est en train de dire.

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

Comme une alternative à CountDownLatch vous pouvez également utiliser CyclicBarrier par exemple

public class ThreadWaitEx {
    static CyclicBarrier barrier = new CyclicBarrier(100, new Runnable(){
        public void run(){
            System.out.println("clean up job after all tasks are done.");
        }
    });
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            Thread t = new Thread(new MyCallable(barrier));
            t.start();
        }       
    }

}    

class MyCallable implements Runnable{
    private CyclicBarrier b = null;
    public MyCallable(CyclicBarrier b){
        this.b = b;
    }
    @Override
    public void run(){
        try {
            //do something
            System.out.println(Thread.currentThread().getName()+" is waiting for barrier after completing his job.");
            b.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }       
}

À utiliser CyclicBarrier dans ce cas de la barrière.await() devrait être la dernière déclaration, c'est à dire quand votre fil est accompli son travail. CyclicBarrier peut à nouveau être utilisé avec la méthode reset (). Pour citer la documentation javadoc:

Un CyclicBarrier prend en charge une option Praticable commande qui est exécutée une fois par barrière point, après le dernier thread dans la partie arrive, mais avant tout les threads sont libérés. Cette barrière d'action est utile pour mettre à jour partagée-état avant de l'une des parties de continuer.