Comment vérifier si toutes les tâches exécutées sur ExecutorService sont terminées

Je v ai ConcurrentLinkedDeque que j'ai choisi pour synchronique push/pop
et je v ai quelques async tâches qui sont un élément de la pile et si cet élément a des voisins C'est en le poussant à pile.

Exemple de code:

private ConcurrentLinkedDeque<Item> stack = new ConcurrentLinkedDeque<>();
private ExecutorService exec = Executors.newFixedThreadPool(5);

    while ((item = stack.pollFirst()) != null) {
                if (item == null) {
                } else {
                    Runnable worker = new Solider(this, item);
                    exec.execute(worker);
                }
            }

   class Solider{
         public void run(){
             if(item.hasNeighbors){
                for(Item item:item.neighbors){
                    stack.push(item)
                }
             } 
         }
    }

Je voudrais avoir relevé supplémentaire dans la boucle while qui répond à la question - "toutes les tâches de l'Exécuteur testamentaire est en train de travailler?"

source d'informationauteur user4129715

  1. 31

    Il n'y a pas un moyen propre à vérifier si tous les Runnables sont nécessaires si vous utilisez ExecutorService.execute(Runnable). Sauf si vous construisez un mécanisme pour le faire dans l'Exécutable lui-même (qui est bâclée à mon avis).

    À la place:

    Utilisation ExecutorService.submit(Runnable). Cette méthode retourne un Future<?> qui est une poignée à la suite d'un exécutable. À l'aide de contrats à Terme fournit un moyen propre de vérifier les résultats.

    Tout ce que vous avez à faire est de maintenir une liste de contrats à Terme que vous soumettez, et puis vous pouvez effectuer une itération sur l'ensemble de la liste des contrats à Terme et soit:

      A) attendre que tous les contrats à terme être fait dans un blocage manière ou d'

      B) de vérifier si toutes les contrats à terme sont faites dans un non-bloquant.

    Voici un exemple de code:

    List<Future<?>> futures = new ArrayList<Future<?>>();
ExecutorService exec = Executors.newFixedThreadPool(5);

//Instead of using exec.execute() use exec.submit()
//because it returns a monitorable future
while((item = stack.pollFirst()) != null){
    Runnable worker = new Solider(this, item);
    Future<?> f = exec.submit(worker);
    futures.add(f);
}

//A) Await all runnables to be done (blocking)
for(Future<?> future : futures)
    future.get(); //get will block until the future is done

//B) Check if all runnables are done (non-blocking)
boolean allDone = true;
for(Future<?> future : futures){
    allDone &= future.isDone(); //check if future is done
}