Java : quel type de ThreadPool dois-je utiliser ici ?

Question

Je viens de commencer à m'exercer à l'utilisation des pools de fils. Je suis en train de créer une application bancaire serveur-client en Java, j'ai parcouru une partie de la documentation d'Oracle et je pense utiliser un pool de threads mis en cache. Mais j'ai effectué quelques tests de comptage et il m'a semblé que le pool de threads fixe était plus rapide. Le pool de threads mis en cache est à la traîne et semble créer trop de threads inutiles. (ou peut-être que je fais quelque chose de mal ici).

Ma question est la suivante : dans une situation réelle, lequel des deux serait le plus efficace ? Ou existe-t-il un autre type de piscine qui serait plus efficace ?

De plus, dans mon test de comptage, j'ai quelques lignes :

ExecutorService executor = Executors.newCachedThreadPool();

    for (int i = 0; i < 500; i++) {
          Runnable worker = new serv(10000000L + i);
          executor.execute(worker);
    }

Dans les lignes ci-dessus, les threads inutilisés sont-ils réutilisés automatiquement (au lieu d'en créer de nouveaux), ou dois-je ajouter quelque chose d'autre pour m'en assurer ?

Answer 1

L'explication se trouve dans Executors.newCachedThreadPool() API

Les fils qui n'ont pas été utilisés pendant soixante secondes sont interrompus et retirés du cache. Ainsi, un pool qui reste inactif suffisamment longtemps ne consommera pas de ressources.

Answer 2

Je suis en retard, vous avez déjà accepté une autre réponse, mais voici mon point de vue :

Je ne recommanderais pas d'utiliser newCachedThreadPool() à moins que vous ne sachiez ce que vous faites. En effet, il créera autant de fils que nécessaire pour exécuter les tâches qui lui sont soumises. Cela peut conduire à des circonstances indésirables telles que l'épuisement des descripteurs ou même le plantage de la JVM en raison de la création d'un trop grand nombre de threads. Bien qu'il supprime les threads inactifs du pool au bout de 60 secondes, il provoque toujours une croissance illimitée.

Je reviens à votre question :

Dans les lignes ci-dessus, les threads inutilisés sont-ils réutilisés automatiquement (au lieu d'en créer de nouveaux), ou dois-je ajouter quelque chose d'autre pour m'en assurer ?

Cela dépend. Supposons que votre chaque Runnable worker prend beaucoup de temps à se terminer (par exemple, 2 minutes). Vous finirez donc par créer 500 threads dans votre boucle. Une fois toutes les tâches terminées, ces 500 threads resteront en mémoire pendant 60 secondes et seront ensuite réclamés.

Si vous souhaitez réutiliser des threads, utilisez 'Executors.newFixedThreadPool(...)` et spécifiez le nombre de threads que vous souhaitez utiliser. Si vous soumettez plus de tâches qu'il n'y a de threads, les tâches attendront dans la file d'attente jusqu'à ce qu'un thread soit disponible.