"Les programmeurs ordinaires se rendent compte tôt ou tard du fait qu'ils ont de nombreuses petites tâches qui doivent être effectuées de temps en temps."
"Si vous écrivez un jeu, ce sont les actions que les personnages individuels effectuent."
"Si vous écrivez un serveur Web, ce sont différentes commandes provenant des utilisateurs : téléchargez une photo, transcodez-la dans le format souhaité, appliquez le modèle souhaité, etc."
"Tôt ou tard, toutes les grandes tâches sont divisées en un ensemble de petites tâches gérables."
"Donc, dans ce contexte, une question subtile se pose : comment êtes-vous censé les gérer toutes ? Et si vous devez effectuer plusieurs centaines de tâches en une minute ? Créer un thread pour chaque tâche n'aurait pas beaucoup de sens. La machine Java alloue beaucoup de ressources pour chaque thread."
"En d'autres termes, créer et détruire un thread peut prendre plus de temps et de ressources que la tâche elle-même."
"Les créateurs de Java ont trouvé une solution élégante à ce problème : ThreadPoolExecutor .
" ThreadPoolExecutor est une classe avec deux choses à l'intérieur :"
A) Une file d'attente de tâches, à laquelle vous pouvez ajouter des tâches au fur et à mesure qu'elles surviennent dans le programme.
B) Un pool de threads, qui est un groupe de threads qui effectuent ces tâches.
"De plus, les threads ne sont pas détruits une fois qu'une tâche est terminée. Au lieu de cela, ils s'endorment afin d'être prêts à démarrer une nouvelle tâche dès qu'elle apparaît."
"Lorsque vous créez un ThreadPoolExecutor , vous pouvez définir le nombre maximum de threads à créer et le nombre maximum de tâches pouvant être mises en file d'attente. En d'autres termes, vous pouvez limiter le nombre de threads à 10, par exemple, et le nombre de tâches en file d'attente à 100."
"Voici comment fonctionne ThreadPoolExecutor :"
1) Lorsque vous ajoutez une nouvelle tâche, elle est placée à la fin de la file d'attente.
2) Si la file d'attente est pleine, une exception est levée.
3) À la fin d'une tâche, chaque thread prend la tâche suivante dans la file d'attente et commence à l'exécuter.
4) S'il n'y a pas de tâches dans la file d'attente, un thread se met en veille jusqu'à ce que de nouvelles tâches soient ajoutées.
"L'approche, où nous limitons le nombre de threads de travail, est avantageuse dans la mesure où plus nous avons de threads, plus ils interfèrent les uns avec les autres. Il est beaucoup plus efficace d'avoir 5 à 10 threads de travail et une longue file d'attente de tâches que créer 100 threads pour un déferlement de tâches, qui vont se concurrencer pour les ressources : mémoire, temps processeur, accès à la base de données, etc."
"Voici un exemple de ThreadPoolExecutor en action :"
ExecutorService service = Executors.newFixedThreadPool(2);
for(int i = 0; i < 10; i++)
{
service.submit(new Runnable() {
public void run()
{
// Here we download something big from the Internet.
}
});
}"Euh, je ne le vois pas..."
"Un objet ThreadPoolExecutor est créé lorsque la méthode newFixedThreadPool est appelée."
Donc, c'est très facile à utiliser. Dès que vous y ajoutez une tâche avec la méthode submit, elle :
A) Réveille un thread endormi, s'il y en a un, pour exécuter la tâche.
B) S'il n'y a pas de thread en attente, il en crée un nouveau pour la tâche.
C) Si le nombre maximum de threads est atteint, il place simplement la tâche à la fin de la file d'attente.
"J'ai délibérément inclus "ici, nous téléchargeons quelque chose de gros sur Internet" dans l'exemple. Si nous avons 100 tâches "téléchargez quelque chose de gros sur Internet", alors cela n'a aucun sens d'en exécuter beaucoup en même temps - nous ' Nous serons limités par la limite de bande passante de notre connexion Internet. Dans ce cas, quelques threads devraient suffire. C'est ce que vous voyez dans l'exemple ci-dessus :"
ExecutorService service = Executors.newFixedThreadPool(2);"Il s'avère que travailler avec un tas de tâches n'est pas si difficile."
"Oui. Encore plus facile que vous ne l'imaginez. Mais Kim vous en parlera."
GO TO FULL VERSION