Comment attendre de tous les threads pour finir, à l'aide de ExecutorService?

Utiliser un CountDownLatch:

CountDownLatch latch = new CountDownLatch(totalNumberOfTasks);
ExecutorService taskExecutor = Executors.newFixedThreadPool(4);
while(...) {
  taskExecutor.execute(new MyTask());
}

try {
  latch.await();
} catch (InterruptedException E) {
   //handle
}

et à l'intérieur de votre tâche (joindre en try /finally)

latch.countDown();

Vous pouvez utiliser des Listes de contrats à Terme, ainsi:

List<Future> futures = new ArrayList<Future>();
//now add to it:
futures.add(executorInstance.submit(new Callable<Void>() {
  public Void call() throws IOException {
     //do something
    return null;
  }
}));

puis, quand vous voulez vous joindre à eux tous, de ses essentiellement l'équivalent de rejoindre à chaque, (avec l'avantage supplémentaire qu'il re-soulève des exceptions de threads à la main):

for(Future f: this.futures) { f.get(); }

Fondamentalement, l'astuce est d'appeler .get() sur chaque Futur, un à un, au lieu de l'infini en boucle appel isDone() sur (toutes ou chacune). Ainsi, vous êtes assuré de "passer" à travers et passé ce bloc dès que le dernier thread se termine. Le problème, c'est que depuis le .get() appel de re-soulève des exceptions, si l'un des fils meurt, vous relèverait d'-ce peut-être avant les autres threads ont fini à l'achèvement [pour éviter cela, vous pouvez ajouter un catch ExecutionException autour de l'obtenir de l'appel]. L'autre inconvénient est qu'elle garde une référence pour tous les threads donc, si ils ont thread variables locales qu'ils ne seront pas recueillis jusqu'à après que vous avez passé ce bloc (bien que vous pourriez être en mesure de contourner ce problème, si il est devenu un problème, en supprimant l'Avenir est sur la liste de tableaux). Si vous voulais savoir qui d'Avenir "qui termine en premier", vous pouvez utiliser quelque chose comme https://stackoverflow.com/a/31885029/32453

Juste mes deux cents.
Pour surmonter la condition de CountDownLatch de connaître le nombre de tâches à l'avance, vous pourriez faire de la bonne vieille façon à l'aide d'un simple Semaphore.

ExecutorService taskExecutor = Executors.newFixedThreadPool(4);
int numberOfTasks=0;
Semaphore s=new Semaphore(0);
while(...) {
    taskExecutor.execute(new MyTask());
    numberOfTasks++;
}

try {
    s.aquire(numberOfTasks);
...

Dans votre tâche appelez simplement s.release() comme vous le feriez latch.countDown();

La CyclicBarrier classe en Java 5 et, plus tard, est conçu pour ce genre de chose.

Vous pouvez rassembler vos tâches dans un autre exécutable, qui envoie des notifications:

taskExecutor.execute(new Runnable() {
  public void run() {
    taskStartedNotification();
    new MyTask().run();
    taskFinishedNotification();
  }
});

Je viens d'écrire un exemple de programme qui permet de résoudre votre problème. Il n'y a pas de concise de mise en œuvre de donnée, donc je vais en ajouter un. Alors que vous pouvez utiliser executor.shutdown() et executor.awaitTermination(), c'est pas la meilleure pratique que le temps pris par les différents threads sont imprévisibles.

ExecutorService es = Executors.newCachedThreadPool();
    List<Callable<Integer>> tasks = new ArrayList<>();

    for (int j = 1; j <= 10; j++) {
        tasks.add(new Callable<Integer>() {

            @Override
            public Integer call() throws Exception {
                int sum = 0;
                System.out.println("Starting Thread "
                        + Thread.currentThread().getId());

                for (int i = 0; i < 1000000; i++) {
                    sum += i;
                }

                System.out.println("Stopping Thread "
                        + Thread.currentThread().getId());
                return sum;
            }

        });
    }

    try {
        List<Future<Integer>> futures = es.invokeAll(tasks);
        int flag = 0;

        for (Future<Integer> f : futures) {
            Integer res = f.get();
            System.out.println("Sum: " + res);
            if (!f.isDone()) 
                flag = 1;
        }

        if (flag == 0)
            System.out.println("SUCCESS");
        else
            System.out.println("FAILED");

    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }

Vous pouvez utiliser ce code:

public class MyTask implements Runnable {

    private CountDownLatch countDownLatch;

    public MyTask(CountDownLatch countDownLatch {
         this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
         try {
             //Do somethings
             //
             this.countDownLatch.countDown();//important
         } catch (InterruptedException ex) {
              Thread.currentThread().interrupt();
         }
     }
}

CountDownLatch countDownLatch = new CountDownLatch(NUMBER_OF_TASKS);
ExecutorService taskExecutor = Executors.newFixedThreadPool(4);
for (int i = 0; i < NUMBER_OF_TASKS; i++){
     taskExecutor.execute(new MyTask(countDownLatch));
}
countDownLatch.await();
System.out.println("Finish tasks");

Vous pouvez utiliser votre propre sous-classe de ExecutorCompletionService pour envelopper taskExecutor, et votre propre mise en œuvre de BlockingQueue d'être informé quand chaque tâche est terminée et effectuer le rappel ou de toute autre action que vous désirez lorsque le nombre de tâches accomplies atteint votre but désiré.

Java 8 - On peut utiliser le volet de l'API de flux de processus. Veuillez voir extrait ci-dessous

final List<Runnable> tasks = ...; //or any other functional interface
tasks.stream().parallel().forEach(Runnable::run) //Uses default pool
//alternatively to specify parallelism 
new ForkJoinPool(15).submit(
() -> tasks.stream().parallel().forEach(Runnable::run) 
).get();

J'ai créé le suivant: exemple de travail. L'idée est d'avoir un moyen de traiter d'un pool de tâches (je suis en utilisant une file d'attente à titre d'exemple) avec de nombreux Fils (déterminé par le programme de l'numberOfTasks/seuil), et attendre jusqu'à ce que toutes les discussions sont en cours pour continuer avec d'autres traitements.

import java.util.PriorityQueue;
import java.util.Queue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/** Testing CountDownLatch and ExecutorService to manage scenario where
* multiple Threads work together to complete tasks from a single
* resource provider, so the processing can be faster. */
public class ThreadCountDown {
private CountDownLatch threadsCountdown = null;
private static Queue<Integer> tasks = new PriorityQueue<>();
public static void main(String[] args) {
//Create a queue with "Tasks"
int numberOfTasks = 2000;
while(numberOfTasks-- > 0) {
tasks.add(numberOfTasks);
}
//Initiate Processing of Tasks
ThreadCountDown main = new ThreadCountDown();
main.process(tasks);
}
/* Receiving the Tasks to process, and creating multiple Threads
* to process in parallel. */
private void process(Queue<Integer> tasks) {
int numberOfThreads = getNumberOfThreadsRequired(tasks.size());
threadsCountdown = new CountDownLatch(numberOfThreads);
ExecutorService threadExecutor = Executors.newFixedThreadPool(numberOfThreads);
//Initialize each Thread
while(numberOfThreads-- > 0) {
System.out.println("Initializing Thread: "+numberOfThreads);
threadExecutor.execute(new MyThread("Thread "+numberOfThreads));
}
try {
//Shutdown the Executor, so it cannot receive more Threads.
threadExecutor.shutdown();
threadsCountdown.await();
System.out.println("ALL THREADS COMPLETED!");
//continue With Some Other Process Here
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
/* Determine the number of Threads to create */
private int getNumberOfThreadsRequired(int size) {
int threshold = 100;
int threads = size / threshold;
if( size > (threads*threshold) ){
threads++;
}
return threads;
}
/* Task Provider. All Threads will get their task from here */
private synchronized static Integer getTask(){
return tasks.poll();
}
/* The Threads will get Tasks and process them, while still available.
* When no more tasks available, the thread will complete and reduce the threadsCountdown */
private class MyThread implements Runnable {
private String threadName;
protected MyThread(String threadName) {
super();
this.threadName = threadName;
}
@Override
public void run() {
Integer task;
try{
//Check in the Task pool if anything pending to process
while( (task = getTask()) != null ){
processTask(task);
}
}catch (Exception ex){
ex.printStackTrace();
}finally {
/*Reduce count when no more tasks to process. Eventually all
Threads will end-up here, reducing the count to 0, allowing
the flow to continue after threadsCountdown.await(); */
threadsCountdown.countDown();
}
}
private void processTask(Integer task){
try{
System.out.println(this.threadName+" is Working on Task: "+ task);
}catch (Exception ex){
ex.printStackTrace();
}
}
}
}

Espère que cela aide!

Cela peut aider

Log.i(LOG_TAG, "shutting down executor...");
executor.shutdown();
while (true) {
try {
Log.i(LOG_TAG, "Waiting for executor to terminate...");
if (executor.isTerminated())
break;
if (executor.awaitTermination(5000, TimeUnit.MILLISECONDS)) {
break;
}
} catch (InterruptedException ignored) {}
}

Il y a une méthode dans exécuteur getActiveCount() - qui donne le nombre de threads actifs.

Après couvrant le fil, nous pouvons vérifier si le activeCount() valeur est 0. Une fois que la valeur est zéro, cela signifie qu'il n'existe pas de threads actifs actuellement en cours d'exécution qui signifie que la tâche est terminée:

while (true) {
if (executor.getActiveCount() == 0) {
//ur own piece of code
break;
}
}