utilisation CompletableFuture sur ForkJoinpool et éviter thread en attente

Question

Bonjour je pensais avec CompletableFuture et la valeur par défaut ForkJoinPool je pourrais optimiser l'exécution de la tâche plus d'un classique ExecutorService mais je manque quelque chose

Avec ce code l'exécution prend 1 seconde, je 3 threads de travail:

for (int i = 0; i < 3; i++) { 
    final int counter = i; 
    listTasks.add(CompletableFuture.supplyAsync(() -> { 
     Thread.sleep(1000); 
     System.out.println("Looking up " + counter + " on thread " + Thread.currentThread().getName()); 
     return null; 
    })); 
} 

OK, semble normal.

Mais avec ce code, il faut 3 secondes:

for (int i = 0; i < 9; i++) { 
    final int counter = i; 
    listTasks.add(CompletableFuture.supplyAsync(() -> { 
     Thread.sleep(1000); 
     System.out.println("Looking up " + counter + " on thread " + Thread.currentThread().getName()); 
     return null; 
    })); 
} 

Je pensais que le fil du sommeil serait utilisé pour lancer d'autres tâches en attente, il devrait aussi prend 1 seconde. J'ai lu par exemple que l'état de thread IO WAINTING signifierait que le thread peut être réutilisé pour une autre tâche. Puis-je tester ce comportement avec Thread.sleep()? Ma méthode de test est-elle incorrecte ou ai-je mal compris quelque chose?

Answer 1

Un thread dormant ne peut pas être utilisé pour faire le travail d'un autre thread (en particulier, un thread ne peut pas dormir pour un autre thread). C'est seulement le CPU qui peut passer au second thread quand le premier se met en veille.

Lorsque vous attribuez une tâche à CompletableFuture.supplyAsync(), l'instance par défaut, ForkJoinPool, comporte autant de threads que votre ordinateur est équipé de processeurs. Vous définissez manuellement trois threads alloués à votre ForkJoinPool par défaut, de sorte que vos neuf tâches sont réparties équitablement entre eux: chaque thread exécute trois tâches de manière consécutive. Donc, vous avez trois secondes comme résultat.

Answer 2

Faisons le calcul. Si vous avez 9 tâches et que chaque tâche dort pendant 1 seconde et que vous avez 2 processeurs, vous ne pouvez exécuter que 2 sessions de 1 seconde à la fois. Exécutez ceci avec 9 tâches et vous obtenez au moins 3 secondes écoulées ou tout au plus 4 secondes écoulées. Ce n'est pas la même chose que les E/S non bloquantes car ce thread Runnable est lié à la CPU et n'abandonnera pas le CPU jusqu'à la fin (malgré le temps de veille). Si vous regardez des choses comme le pool de threads IO de RxJava, il crée un thread par tâche qui est acceptable pour les tâches IO (mais pas pour les tâches liées au CPU).