Fil de discussion.join() équivalent en exécuteur testamentaire

J'ai une question de newbie. J'ai ce code:

public class Main 
{

    public static void main(String[] args) throws InterruptedException 
    {
        //TODO Auto-generated method stub
        IntHolder aHolder=new IntHolder();
        aHolder.Number=0;

        IncrementorThread A= new IncrementorThread(1, aHolder);
        IncrementorThread B= new IncrementorThread(2, aHolder);
        IncrementorThread C= new IncrementorThread(3, aHolder);

        A.start();
        B.start();
        C.start();

        A.join();
        B.join();
        C.join();
        System.out.println("All threads completed...");

    }

}

Qui va attendre que tous les threads complète. Si j'utilise Executors comme ceci:

public class Main 
{

    public static void main(String[] args) 
    {
        //TODO Auto-generated method stub
        IntHolder aHolder=new IntHolder();
        aHolder.number=0;

        IncrementalRunable A= new IncrementalRunable(1, aHolder);
        IncrementalRunable B= new IncrementalRunable(2, aHolder);
        IncrementalRunable C= new IncrementalRunable(3, aHolder);

        ExecutorService exec = Executors.newFixedThreadPool(3);
        exec.execute(A);
        exec.execute(B);
        exec.execute(C);
        //Don't know what to do here

        System.out.println("All threads completed...");
    }
}

Comment puis-je suspendre le thread principal d'attendre que tous les fils de l'exécuteur testamentaire, pour finir, je.e le "Tous les threads terminé..." doit être imprimé après tous les threads ont fait leur travail?

vérifiez ceci : stackoverflow.com/questions/3269445/...
Demain a un blocage de la méthode get

OriginalL'auteur Mario Stoilov | 2013-12-10

14
```
executor.shutdown();
while (!executor.awaitTermination(24L, TimeUnit.HOURS)) {
    System.out.println("Not yet. Still waiting for termination");
}
```
Utilisation shutdown() + awaitTermination() combinaison.

EDIT:

Basé sur le commentaire de @Lital
```
List<Callable<Object>> calls = new ArrayList<Callable<Object>>();
calls.add(Executors.callable(new IncrementalRunable(1, aHolder)));
calls.add(Executors.callable(new IncrementalRunable(2, aHolder)));
calls.add(Executors.callable(new IncrementalRunable(3, aHolder)));

List<Future<Object>> futures = executor.invokeAll(calls);
```
NOTE:
invokeAll() ne sera pas de retour jusqu'à ce que toutes les tâches sont terminées (soit par défaut ou de remplir le succès de l'exécution).

Ne pensez-vous pas qu'il n'est pas de bonne pratique de l'arrêt d'un pool de thread juste pour le plaisir d'une simple jointure?
J'ai ajouté un autre chouette approche qui peut être suivie.
génial, c'est encore mieux, mais de changer les numéros 1,2,3 (ceux qui sont fil des numéros que j'utilise pour imprimer des messages)
Btw: il n'y a pas de attendre la résiliation, sauf si vous avez besoin de réagir. Donc, si tout ce que vous faites par la suite est de la fin du programme, un simple shutdown() appel est suffisant, si vous savez que le fils se terminent correctement. Sinon, un puissant shutdownNow() est nécessaire comme une réaction à shutdown().
Fait, une faute de frappe 🙂

OriginalL'auteur Narendra Pathai

Vous ne devriez pas utiliser exécuteur de ce genre si vous voulez attendre pour les tâches de finition.
Que faire si vous ne voulez pas/ne pouvez pas arrêter votre pool de threads exécuteur testamentaire?
C'est une méthode recommandée:

    ExecutorService exec = Executors.newFixedThreadPool(3);
    Collection<Future<?>> tasks = new LinkedList<Future<?>>();

    Future<T> future = exec.submit(A);
    tasks.add(future);
    future = exec.submit(B);
    tasks.add(future);
    future = exec.submit(C);
    tasks.add(future);

    //wait for tasks completion
    for (Future<?> currTask : tasks) {
            try {
                currTask.get();
            } catch (Throwable thrown) {
                Logger.error(thrown, "Error while waiting for thread completion");
            }
        }

Je suis d'accord que je ne devrais pas utiliser les exécuteurs comme ça, mais je suis juste dupant autour avec java maintenant et j'étais curieux comme à comment je pourrais réaliser que

OriginalL'auteur Lital Kolog

0

Essayer de travailler avec un pool de threads de cette façon.
```
executor.shutdown();
executor.awaitTermination(MAX_PRIORITY, TimeUnit.HOURS);
```
OriginalL'auteur Abdul Rasheed Mohammed

-1

 exec.shutdown();
    //Wait until all threads are finish
    exec.awaitTermination();

OriginalL'auteur Satheesh Cheveri

Vous devez vous connecter pour publier un commentaire.