Qu'est-ce qu'un pool de threads?
Comment implémenterait-on un pool de threads? J'ai lu sur wikipedia pour "threadpool" mais je n'arrive toujours pas à comprendre ce qu'il faut faire pour résoudre cette question (peut-être parce que je ne comprenais pas très bien ce qu'est un threadpool en termes simples).
Quelqu'un peut-il m'expliquer en anglais simple ce qu'est un pool de threads et comment répondrait-on à cette question?
Un pool de threads est un groupe de threads inactifs pré-instanciés qui sont prêts à recevoir du travail. Celles-ci sont préférées à l'instanciation de nouveaux threads pour chaque tâche lorsqu'il y a un grand nombre de tâches courtes à effectuer plutôt qu'un petit nombre de longues. Cela évite d'avoir à supporter la surcharge de création d'un thread un grand nombre de fois.
La mise en œuvre variera selon l'environnement, mais en termes simplifiés, vous avez besoin des éléments suivants:
- Un moyen de créer des threads et de les maintenir dans un état inactif. Cela peut être accompli en faisant attendre chaque thread à une barrière jusqu'à ce que la piscine le remette en marche. (Cela pourrait également être fait avec des mutex.)
- Un conteneur pour stocker les threads créés, comme une file d'attente ou toute autre structure qui a un moyen d'ajouter un thread au pool et d'en extraire un.
- Une interface standard ou une classe abstraite pour les threads à utiliser pour effectuer le travail. Il peut s'agir d'une classe abstraite appelée
Taskavec une méthodeexecute()qui effectue le travail puis retourne.
Lorsque le pool de threads est créé, il instanciera un certain nombre de threads à rendre disponibles ou en créera de nouveaux en fonction des besoins de l'implémentation.
Lorsque le pool reçoit un Task, il prend un thread du conteneur (ou attend qu'il en devienne disponible si le conteneur est vide), lui donne un Task et rencontre la barrière. Cela entraîne la reprise de l'exécution du thread inactif, en invoquant la méthode execute() de la Task qui lui a été donnée. Une fois l'exécution terminée, le fil se remet à la piscine pour être mis dans le conteneur pour être réutilisé, puis rencontre sa barrière, s'endormant jusqu'à ce que le cycle se répète.
Le pool de threads est une collection de threads gérés généralement organisés dans une file d'attente, qui exécutent les tâches dans la file d'attente des tâches.
La création d'un nouvel objet de thread chaque fois que vous avez besoin que quelque chose soit exécuté de manière asynchrone coûte cher. Dans un pool de threads, vous ajouteriez simplement les tâches que vous souhaitez exécuter de manière asynchrone à la file d'attente de tâches et le pool de threads prend soin d'attribuer un thread disponible, le cas échéant, pour la tâche correspondante. Dès que la tâche est terminée, le thread maintenant disponible demande une autre tâche (en supposant qu'il en reste).
Le pool de threads vous aide à éviter de créer ou de détruire plus de threads que cela ne serait vraiment nécessaire.
Je commencerais par créer une classe avec une file d'attente de threads et une file d'attente de tâches. Ensuite, implémentez une méthode qui ajoute une tâche à la file d'attente des tâches et continuez à partir de là. Évidemment, vous devez également permettre de définir le nombre maximal de threads autorisés dans un pool de threads.
Exemple réel;
- Installation: système d'exploitation
- Sections: Applications
- Personnes: Threads
Vous avez une installation là-bas, 12 personnes travaillent. Il y a 3 sections de cette installation. Cuisine, toilettes et sécurité. Si vous n'utilisez pas la technique du pool de threads, c'est ainsi que cela fonctionne: les 12 personnes seront debout dans une salle de réunion, si de nouveaux clients viennent par établissement et demandent des tâches, alors vous séparerez les personnes en groupes et les enverrez pour faire leur travail et revenez à la salle de réunion. Mais, avant de partir en mission, il y a une phase de préparation. Ils doivent porter l'uniforme correct, équiper certains appareils et marcher jusqu'à cette section, terminer le travail et revenir. Ainsi, une fois à chaque fois qu'ils terminent leur travail (le fil se termine), ils doivent retourner à la salle de réunion, se déshabiller, retirer le matériel et attendre le prochain travail. Ceux-ci se réfèrent à la création de contexte de thread, c'est l'allocation de mémoire et les informations de suivi par OS. Le système d'exploitation prend trop de temps pour réorganiser les nouveaux besoins de threads.
Si vous utilisez le pool de threads, alors, tôt le matin, vous affecterez 6 personnes à la cuisine, 2 personnes aux toilettes et 4 personnes à la sécurité. Ainsi, ils ne feront leur préparation qu'une fois par jour. Même s'il n'y a pas de clients à la cuisine, ces 4 personnes seront là, au ralenti, pour toutes les tâches à venir. Ils n'ont pas besoin de retourner dans la salle de réunion jusqu'à la fermeture de la cuisine (fin de l'application). Ces 4 personnes sont dans la piscine de l'application Kitchen et sont prêtes à servir rapidement. Mais, vous ne pouvez pas promettre qu'ils travaillent toute la journée, car la cuisine peut devenir inactive de temps en temps. La même logique s'applique également aux toilettes et à la sécurité.
Dans le premier scénario, vous ne gaspillez aucun thread pour aucune tâche, MAIS cela prendra beaucoup de temps pour préparer chaque thread pour chaque tâche. Dans le second, vous préparez les threads à l'avance, vous ne pouvez donc pas garantir que vous utiliserez tous les threads pour toutes les tâches, mais le système d'exploitation fait généralement une excellente optimisation, vous pouvez donc vous y fier en toute sécurité.
Dans une application multithread, le pool de threads est un "pool de threads disponibles" qui peut être utilisé par votre application. Habituellement, par exemple .NET, tout est géré donc vous attribuez simplement des tâches et une fois qu'un thread est libre, il va l'exécuter. Donc, pour implémenter un pool de threads, je m'attendrais à créer un concept où les tâches sont automatiquement prises par des threads libres sans création explicite de threads pour chaque tâche.