l'arrêt et awaitTermination qui premier appel avez-vous la différence?

Quelle est la différence entre

ExecutorService eService = Executors.newFixedThreadPool(2);
eService.execute(new TestThread6());
eService.execute(new TestThread6());
eService.execute(new TestThread6());
eService.awaitTermination(1, TimeUnit.NANOSECONDS);
eService.shutdown();

et

eService.shutdown();
eService.awaitTermination(1, TimeUnit.NANOSECONDS);

Je ne comprends pas vraiment shutdown(). Cette méthode ne permet pas d'attendre précédemment soumis tâches d'exécution. Signifie-t-il shutdown() peut résilier les tâches qui leur ont été soumis, mais pas terminé? J'ai essayé quelques exemples, ils ne prouvent pas, s'il vous plaît donnez-moi un exemple.

InformationsquelleAutor Amitābha | 2013-08-25
  1. 40

    Vous devriez appeler shutdown premier. Sinon, vous risquez d'attendre très longtemps, depuis awaitTermination ne fait pas de l'arrêt de votre exécuteur testamentaire.

    Si vous voulais attendre pour les tâches à effectuer, plutôt que d'attendre que l'exécuteur testamentaire à l'arrêt, alors vous devriez utiliser invokeAll.

    • merci,mais pourquoi attendre pour un temps très long?pourriez-vous me donner quelques exemple pour expliquer?
    • ne fait pas de l'arrêt de votre exécuteur de la première. Donc, sauf si un autre thread s'arrête à l'exécuteur testamentaire, awaitTermination va rester là jusqu'à ce que la temporisation s'exécute. Évidemment, dans votre exemple, vous avez été en attente seulement 1 nanoseconde avant d'expirer, ce qui explique pourquoi vous n'avez pas d'observer le "très longtemps".
    • merci,je comprends,et dans l'arrêt() de l'api:Cette méthode ne permet pas d'attendre précédemment soumis tâches d'exécution. cela signifie peut-être shutdown() peut mettre fin à la tâche qui l'ont soumis,mais pas complet?mais j'ai essayer quelques exemples pas le prouver
    • Correct, tout incomplète tâches seront annulés (leur fils sera envoyé interruptions). Si vos tâches à ne pas vérifier les interruptions, cependant, d'annulation de la formation ne fonctionne pas.
    • s'il vous plaît regardez ce code public class TestThread9 implements Runnable{ @Override public void run() { if (Thread.interrompu()) { System.out.println("interrompu"); return; } System.out.println("a"); } public static void main(String[] args) throws InterruptedException { ExecutorService eService = Exécuteurs testamentaires.newFixedThreadPool(2); eService.execute(nouveau TestThread9()); eService.execute(nouveau TestThread9()); eService.shutdown(); } }dans cet exemple,j'ai seulement appel de l'arrêt(),pas d'appel awaitTermination ,et je vérifie interrompre, mais pas "interrompue", a imprimer
    • Votre tâche terminée avant il a été interrompu. Essayez de faire quelque chose comme: while (!Thread.interrupted()) {System.out.println("loop"); Thread.sleep(1000);}. Vous verrez les résultats.
    • j'essaie d'utiliser votre code et d'appel de l'arrêt(),mais ne jamais se terminer,et l'impression de "boucle" pour toujours:public class TestThread9 implements Runnable{ @Override public void run() { while (!Fil de discussion.interrompu()) {System.out.println("loop"); try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-généré bloc catch e.printStackTrace(); }} } public static void main(String[] args) throws InterruptedException { ExecutorService eService = Exécuteurs testamentaires.newFixedThreadPool(2); eService.execute(nouveau TestThread9()); eService.execute(nouveau TestThread9()); eService.shutdown(); }
    • Notez que shutdown() n'interrompt pas déjà en cours d'exécution des tâches. De javadoc : "Initie un arrêt dans lequel précédemment présenté les tâches sont exécutées, mais pas de nouvelles tâches seront acceptées." Si vous voulez interruption, vous devez appeler shutDownNow().
    • Ce bowmore dit. (Juste dit que pour mettre en surbrillance votre nom, afin que vous soyez averti de l'.)
    • l'arrêt met fin à toutes les discussions et awaitTermination après l'arrêt est redondante.
    • Non, ce n'est pas ce que dit la documentation. Voir S. D. réponse. Ce que vous décrivez est ce que shutdownNow n'.

    InformationsquelleAutor Chris Jester-Young
  2. 37

    La lecture de la documentation est toujours utile:

    shutdownNow :

    Essaie d'arrêter tous les activement à l'exécution des tâches, arrête le traitement de
    tâches en attente, et renvoie une liste des tâches qui ont été en attente d'
    l'exécution. Ces tâches sont drainés (supprimé) à partir de la tâche de la file d'attente lors de l'
    de retour de cette méthode.

    Cette méthode ne pas attendre activement à l'exécution des tâches pour mettre fin.
    Utilisation awaitTermination de le faire.

    Il n'y a pas de garanties au-delà de best-effort tente d'arrêter le traitement
    activement à l'exécution des tâches. Cette mise en œuvre annule tâches à l'aide de
    Fil de discussion.interrupt(), toute tâche qui ne répond pas aux interruptions
    peut ne jamais mettre fin à

    arrêt:

    Initie un arrêt dans lequel déjà soumis tâches sont
    exécuté, mais pas de nouvelles tâches seront acceptés.     L'Invocation n'a pas de
    effet supplémentaire si déjà arrêtée.

    Cette méthode ne permet pas d'attendre précédemment soumis tâches à effectuer
    l'exécution. Utilisation awaitTermination de le faire.

    awaitTermination:

    Blocs jusqu'à ce que toutes les tâches ont terminé l'exécution après une demande d'arrêt, ou le délai d'attente se produit, ou si le thread est interrompu,
    selon la première éventualité.

    • Je ne comprends pas la documentation pour l'arrêt. Il est le premier à dire "déjà soumis les tâches sont exécutées", et puis il dit "cette méthode ne permet pas d'attendre précédemment soumis tâches d'exécution." Donc, mes tâches sont exécutées jusqu'à la fin ou pas?
    • Il entend l'appel de la méthode retourne immédiatement. I. e. le thread qui appelle shutdown n'a pas de blocs.
    • Ahh, ne bloque pas. Qui fait sens aujourd'hui. Ils devraient ai utilisé ce mot plutôt que d'attendre. Merci.
    InformationsquelleAutor S.D.
  3. 13

    arrêt signifie que l'exécuteur testamentaire prend pas plus de tâches entrantes.

    awaitTermination est invoquée après une demande d'arrêt.

    Vous devez d'abord arrêter le service, et ensuite de bloquer et d'attente pour les threads à la fin.

    Si vous voulez voir toutes les discussions de fin de l'exécution et d'insister sur l'utilisation de awaiTermination, vous devez définir le paramètre de délai d'attente pour être assez grand. De sorte que vous pouvez faire:

    eService.shutdown();
if (!eService.awaitTermination(60000, TimeUnit.SECONDS))
    System.err.println("Threads didn't finish in 60000 seconds!");
}

    Alternativement, vous pouvez faire:

    eService.shutdown();
while (!eService.isTerminated()) {

}

    De cette façon, vous êtes en mesure de s'assurer que tous les fils sont terminés en cours d'exécution, sauf s'ils sont interrompu de façon inattendue.

    • vous signifiait probablement millisecondes... 60000s est 16.666 heures.
    • Ne font pas un occupé-attendre comme le deuxième extrait de code. Juste. Ne le faites pas.
    InformationsquelleAutor Terry Li
  4. 2

    Après notre départ de la première tâche ThreadPoolExecutor va démarrer un Thread qui n'aura pas de fin, même après que la tâche est terminée. Au moins, il est vrai pour un pool de threads. C'est pourquoi nous avons besoin de faire appel de l'arrêt. Après l'arrêt ThreadPoolExecutor rejettera toute nouvelle tâche mais va attendre pour l'exécution de tâches pour terminer et ensuite laisser les Fils à la fin. C'est pourquoi nous avons besoin de awaitTermination après shutdwon.

    InformationsquelleAutor Evgeniy Dorofeev
  5. 0
    executorService.execute(runnableTask);  

//executorService.shutdown(); //it will make the executorService stop accepting new tasks
//executorService.shutdownNow(); //tires to destroy the executorService immediately, but it doesn't guarantee that all the running threads will be destroyed at the same time. This method returns list of tasks which are waiting to be processed.
//List<Runnable> notExecutedTasks = executorService.shutdownNow(); //this method returns list of tasks which are waiting to be processed.developer decide what to do with theses tasks?

//one good way to shutdown the executorService is use both of these methods combined with the awaitTermination
executorService.shutdown();
try{
    if(!executorService.awaitTermination(1000, TimeUnit.MICROSECONDS)) {
        executorService.shutdownNow();
    }
}catch (InterruptedException e){
    e.printStackTrace();
}
    InformationsquelleAutor user11656780
  6. -2

    Vous devez appeler shutdownNow() méthode après la awaitTermination() appel de méthode qui s'est passé. Puis seulement vous pouvez trouver de l'utilisation réelle de awaitTermination() méthode.

    InformationsquelleAutor user3094331