web-dev-qa-db-fra.com

Comment Threadpool réutilise les threads et comment cela fonctionne

Mes concepts multithreads sont faibles et essayent d'apprendre.

Dans Java ce que je sais, nous ne pouvons pas appeler un thread plus d'une fois:

Thread t = new Thread; //Some Runnable
t.start();

t.start(); //Illegal and throw Exception at runtime.

Pour autant que je sache, il lève une exception lorsque vous appelez à nouveau t.start() car la pile associée pour le thread est détruite une fois qu'elle sort de la méthode run() et que vous essayez d'initialiser à nouveau les choses .

Dans ce cas, ce que je sais sur le pool de threads, c'est qu'il offre de meilleures performances et fait gagner du temps car il n'est pas nécessaire de créer un nouveau thread (j'ai lu this ).

S'il n'est pas nécessaire de créer un nouveau thread dans le scénario du pool de threads, comment cela fonctionne-t-il avec le même thread qui vient de terminer sa méthode d'exécution, ce thread peut-il être réutilisé?

J'ai lu this , et il est dit que " La plupart des implémentations d'exécuteur dans Java.util.concurrent utilisent des pools de threads, qui se composent de threads de travail. Ce type de thread existe séparément des tâches exécutables et appelables qu'il exécute et est souvent utilisé pour exécuter plusieurs tâches. "

Alors, quel est le thread Worker ici, est-ce quelque chose de différent alors normal Java threads?

Avec le lien this , j'ai quelque chose mais je ne sais toujours pas quel genre de choses peut être éliminé lorsque nous utilisons le pool de threads et pourquoi il donne de meilleures performances que l'utilisation de threads normaux Java .

Alors peut-on dire comme ça,

Le fil comporte trois parties,

  1. Création (en disant au système d'exploitation qu'il s'agit d'un nouveau thread, créez une pile pour celui-ci.)
  2. Exécutez Runnable avec la méthode run ().
  3. Détruire les threads.

Ainsi, compte tenu des étapes ci-dessus, avec le pool de threads, l'étape 1 et l'étape 3 peuvent être éliminées après un nombre fixe de création de threads. Seule l'étape 2 pour chaque tâche sera exécutée, c'est pourquoi threadpool est plus rapide? Pouvons-nous dire comme ça? Ai-je raison?

javamultithreadingconcurrencythreadpool
44
Jayesh

S'il n'est pas nécessaire de créer un nouveau thread dans le scénario ThreadPool, comment cela fonctionne-t-il avec le même thread qui vient de terminer sa méthode d'exécution, ce thread peut-il être réutilisé?

Simple - le fil d'origine ne se termine jamais réellement. Il attend juste qu'une autre tâche soit exécutée. En pseudo-code:

// No, this isn't even slightly accurate! General impression only :)
while (!pool.isShutdown()) {
    Runnable task = pool.waitForTaskOnQueue();
    task.run();
}

(Évidemment, lorsqu'un pool de threads est arrêté, il devrait également empêcher les threads en attente d'attendre une autre tâche - mais j'espère que vous aurez une idée générale.)

34
Jon Skeet

Le processus fonctionne en deux parties:

Soumission de la tâche: les pools de threads sont étroitement associés à une file d'attente de blocage. Quand nous disons executor.execute (runnable). L'exécutable/appelable est interrogé dans la file d'attente.

Exécution des tâches: les tâches doivent maintenant être récupérées dans la file d'attente. Disons que chaque fois qu'une tâche est soumise dans la file d'attente, elle doit être récupérée et exécutée.

Il y a donc des threads qui exécuteront une boucle infinie et surveilleront la file d'attente des tâches. Dès que les tâches sont disponibles, un thread les sélectionne et les exécute.

3
Sonu

Dans le pool de threads Au lieu de créer de nouveaux threads lorsque de nouvelles tâches arrivent, un pool de threads conserve un certain nombre de threads inactifs qui sont prêts à exécuter des tâches selon les besoins. Une fois qu'un thread a terminé l'exécution d'une tâche, il ne meurt pas. Au lieu de cela, il reste inactif dans le pool en attente d'être choisi pour exécuter de nouvelles tâches.

Vous pouvez limiter un nombre défini de threads simultanés dans le pool, ce qui est utile pour éviter une surcharge. Si tous les threads exécutent activement des tâches, de nouvelles tâches sont placées dans une file d'attente, l'attente d'un thread devient disponible

2
Vinayak Bansal

Ainsi, compte tenu des étapes ci-dessus, avec Threadpool, les étapes 1 et 3 peuvent être éliminées après un nombre fixe de création de threads. seule l'étape 2 pour chaque tâche sera exécutée, c'est pourquoi Threadpool est plus rapide? pouvons-nous dire comme ça? Ai-je raison?

Oui vous avez raison. La création et la destruction de fils sont l'une des tâches coûteuses. Comme dans un pool de threads, les threads sont déjà créés, de sorte que la surcharge de la création de threads n'est pas là. Mais si vous avez des threads beaucoup plus élevés qu'il ne devrait en avoir, ce sera très mauvais pour votre application. Il peut s'agir de OutofMemorry ou de certains autres problèmes. Donc, pour fixer une taille de pool de threads, utilisez la formule ci-dessous:

no of threads = 2 * no_of_cores * no_of_disks * percentage CPU utilization you need * (1 + (W/ C))

(W/C) est la fraction indiquant le temps d'attente pour calculer le temps.

1
Trying