Java Thread Pools / Executor Service et wait () s - que deviennent les threads & amp; file d'attente de tâches?

wait() est une opération de blocage:

Le thread actuel d'attendre jusqu'à ce qu'un autre thread appelle le notify() ou notifyAll()

Cela signifie que le fil dans la piscine va attendre, mais de l'extérieur il ressemble à la tâche en cours prend tellement de temps pour terminer. Cela signifie également que si 5 les tâches sont exécutées et ils ont tous wait()le Executor ne peut pas gérer les tâches restantes, ekhem, attendre dans la file d'attente.

Vrai, l'exécuteur fil lui-même va dormir, permettant à d'autres threads de basculer et de consommer du CPU (donc vous pouvez avoir des centaines de threads en attente en même temps et que votre système est toujours réactive) mais toujours le thread est "inutilisable" et bloqué.

Une autre caractéristique intéressante est interrompre - si le thread attend quelque chose ou dort, vous pouvez l'interrompre. Notez que les deux wait() et Thread.sleep() déclarer InterruptedException. Avec ExecutorService vous pouvez prendre avantage de cela en appelant simplement: avenir.annuler() (future est l'objet que vous avez reçu en retour lorsque soumettre tâche à ExecutorService).

Enfin je pense que vous devriez revoir la conception de votre solution. Au lieu de activement d'attente pour un système externe pour terminer, fournir une API avec les rappels:

pool.execute(new Runnable(){
    try{
        doSomethingAndCallMeBackWhenItsDone(new Callback() {
            public void done() {
                doSomethingElse();
            }
        });
    }catch(Exception e){ throw new RunTimeException(e) } 

});

De cette façon, le système externe de l'API tout simplement vous aviser lorsque les résultats sont prêts et que vous n'avez pas à attendre et de bloquer ExecutorService. Enfin, si doSomethingElse() prend beaucoup de temps, vous pourriez même décider de le programmer ainsi, plutôt que de l'aide de tiers externe I/O fil:

pool.execute(new Runnable(){
    try{
        doSomethingAndCallMeBackWhenItIsDone(new Callback() {
            public void done() {
                pool.submit(new Callbale<Void>() {
                    public Void call() {
                        doSomethingElse();
                    }
                }
            }
        });
    }catch(Exception e){ throw new RunTimeException(e) } 

});

Mise à JOUR: vous vous demandez quoi faire au sujet des délais d'attente? Voici mon idée:

pool.execute(new Runnable(){
    try{
        doSomethingAndCallMeBackWhenItsDone(new Callback() {
            public void done() {
                doSomethingElse();
            }
            public void timeout() {
                //opps!
            }
        });
    }catch(Exception e){ throw new RunTimeException(e) } 

});

Je suppose que vous pouvez mettre en œuvre délai d'attente de la troisième partie côté et si le délai d'attente se produit, il vous suffit d'appeler timeout() méthode.

J'avais commentaire sur Tomasz la réponse, mais ma réputation ne le permet pas (encore), désolé.

Je sais que la question est ancienne, mais pour les gens qui continuent à la lecture de cette page, avoir un regard sur l'Avenir et surtout de goyave est ListenableFuture qui vous permet d'enregistrer des rappels et de la chaîne de l'avenir, précisément, le but de ne pas bloquer votre thread (et donc gratuit le fil de retour à la piscine pour quelque chose d'autre pour l'utiliser).