‫Bienvenue à nouveau et cette vidéo, nous allons examiner les pools de menaces, nous allons donc créer plusieurs threads
‫et voir ce qui va se passer.
‫Par conséquent, commençons par créer simplement un fil de discussion très basique, et je vais me débarrasser
‫de ce truc de source de complétion.
‫Et donc nous sommes à un fil très générique ici.
‫C'est donc un fil générique que nous avons utilisé jusqu'à présent.
‫Et ici on attend une seconde, par exemple, et ça a un fil.
‫Non.
‫Et pour le démarrer, bien sûr, nous devons appeler la méthode start ici vers la fin.
‫Alors maintenant, ça va être juste un fil et ça va commencer.
‫Donc rien de nouveau ici.
‫Nous l'avons fait plusieurs fois là-bas.
‫Donc, la seule différence est que maintenant j'aimerais utiliser quelque chose appelé un pool de threads.
‫Mais avant de faire cela, je vais simplement utiliser une facture numérable et numérique comme celle-ci,
‫et je vais exécuter une plage de zéro à, disons, 100 pour l'instant, deux listes et pour chaque entrée.
‫Je voudrais faire quelque chose.
‫Je vais donc simplement dire qu'il suffit d'exécuter un code spécifique.
‫Ce n'est donc qu'une ligne de code à peu près.
‫Et là-dedans, je veux créer des fils.
‫Donc, ce qui va faire, c'est que cet énumérable ou cet énumérable va en fait créer
‫plusieurs threads et en créer 100.
‫Je vais donc utiliser un lien ici.
‫Donc, en utilisant le lien système afin d'utiliser l'énumérable et il devrait être appelé range avec lui à la fin pour que
‫nous soyons.
‫Donc, cela suffira, c'est simplement créer 100 menaces et nous verrons toutes ces menaces sur la console.
‫Alors commençons par ça.
‫Et nous y sommes.
‫Et comme vous pouvez le voir, cela commence les fils et il termine les fils et cent deux est le dernier
‫fil.
‫Et je peux voir que ça a commencé avec trois.
‫Cela commence donc par trois, six, cinq et ainsi de suite.
‫L'ordre, comme vous pouvez le voir, est donc très différent de ce à quoi nous nous attendions.
‫Ainsi, les threads ont un ID différent de l'ordre dans lequel nous nous attendions à ce qu'ils soient, mais ils sont ensuite
‫démarrés et terminés et c'était peut-être un peu trop rapide.
‫Créons donc un peu plus de menaces ou je dirais 1000 threads.
‫Et comme vous pouvez le voir.
‫Cela crée des tonnes de threads, mais les threads sont terminés avant que d'autres ne commencent.
‫Il y en a donc d'innombrables, il les démarre là où il les crée aussi vite que possible, aussi vite que possible.
‫Mais comme vous pouvez le voir, cela prend un peu de temps.
‫Alors disons environ une centaine de millisecondes pour créer un fil que nous sommes, il les crée et ensuite il
‫commence à les terminer.
‫Donc, après une seconde, il a créé six threads seulement, puis cinq threads.
‫L'un des premiers était donc terminé.
‫Donc, comme vous pouvez le voir, cela crée ces menaces.
‫Et ce n'est pas très efficace parce que, eh bien, nous ne pouvons pas contrôler ces menaces.
‫Nous ne pouvons pas contrôler ce nombre de menaces.
‫Et c'est un aspect très important.
‫Les menaces que vous devez être très, très prudent et très précis lorsque vous travaillez avec des menaces.
‫Vous devez savoir ce que vous voulez faire avec cette menace et les Blancs là-bas et comment travailler généralement avec tout ce qui
‫se trouve dans la menace.
‫Ce n'est donc qu'un exemple de menaces, comment vous pouvez en créer plusieurs.
‫Et cela a juste créé un millier de menaces comme ça.
‫Et maintenant, regardons les pools de menaces car leurs pools ont une approche légèrement différente
‫et utilisent des menaces et ils sont un peu plus sécurisés, disons, car ils ne créent pas mille menaces qui ne
‫sont pas nécessaires.
‫Il ne contient que les menaces actuellement requises.
‫Créons donc un pool de menaces ici.
‫Et élément de travail de l'utilisateur Q.
‫Q est une méthode d'exécution qui s'exécute lorsqu'une menace de pool de menaces devient disponible.
‫Donc, seulement s'il est disponible, alors cela sera exécuté et il a besoin d'un objet ici.
‫Il y en a donc deux différents ici pour voir le rappel et l'objet et je vais juste lui donner un oh
‫comme un objet.
‫Je vais juste l'appeler.
‫Oh, rien de spécial ici.
‫Et qu'est-ce que je vais exécuter dans le pool de menaces.
‫Alors je vais juste dire donnez-moi le I. RÉ. de la menace ou du numéro de la menace et bien disons quand elle a
‫commencé et quand elle s'est terminée.
‫C'est donc à peu près tout ce que je veux faire avec ce pool de menaces.
‫Et comme vous pouvez le voir ici, nous ne créons pas spécifiquement, nous ne créons pas de menaces là-dedans.
‫Mais ce pool de menaces le fera pour nous.
‫Il y a donc beaucoup de travail à faire, comme mille menaces à gérer.
‫Et comme vous pouvez le voir, cela ne crée qu'un nombre spécifique de menaces.
‫Et comme vous pouvez le voir, cela démarre et termine les menaces plus ou moins en même temps.
‫Et vous pouvez voir aussi que je n'ai pas beaucoup d'appels sur mon processeur ici car il ne peut fonctionner qu'avec un nombre spécifique
‫de menaces en même temps.
‫Ainsi, le pool de menaces gérera les choses beaucoup plus facilement, comme vous pouvez le voir.
‫Mais bien sûr, il faut beaucoup de temps pour surmonter toutes ces 1000 menaces.
‫Mais comme je l'ai dit, si vous utilisez des menaces, vous devez les contrôler, donc n'utilisez pas de menaces au hasard, à peu près
‫la principale chose où vous utiliseriez des menaces est lorsque vous faites quelque chose en arrière-plan et vous faites quelque
‫chose au premier plan.
‫Ainsi, au premier plan se trouve généralement quelque chose comme l'interface utilisateur.
‫Donc, lorsque vous utilisez WP F ou si vous utilisez des applications avec Gamoran ou créez l'absolutisme, alors tout ce qui se passe
‫à l'avant et donc dans l'interface utilisateur est fait par la menace principale puis ou par la menace de l'interface utilisateur, puis
‫quelque chose comme télécharger des vidéos ou télécharger des données en général à partir d'Internet ou accéder aux données
‫du disque dur ou de la carte SD ou autre.
‫Tout ce qui pourrait prendre un peu de temps, même si ce n'est que quelques millisecondes
‫ou un autre couple, mais plusieurs millisecondes, alors c'est déjà quelque chose qui devrait être fait en arrière-plan car
‫sinon votre interface utilisateur sera gelée parce que, eh bien, elle n'est pas prête à faire quelque chose parce que les menaces sont
‫toutes occupées.
‫Très bien, il s'agit donc de créer des pools de menaces et si vous avez beaucoup de choses à faire, vous pouvez utiliser des pools
‫de menaces.
‫Il y a donc plusieurs choses à considérer lors de l'utilisation des pools de menaces, donc généralement les pools de
‫menaces sont là pour exécuter un travail spécifique ou effectuer des travaux ou des éléments de travail spécifiques, et ils attendront pratiquement jusqu'à ce que la
‫prochaine menace soit prête ou qu'une menace soit terminée avant elle. départs.
‫La prochaine menace ou avant qu'elle ne commence avec le prochain élément de travail.
‫C'est donc l'avantage des pools de menaces, qu'ils n'ont pas de temps d'inactivité ou de temps de veille où il ne se
‫passe pratiquement rien, car il peut y avoir des situations où tout simplement rien ne doit être fait avec votre
‫ou votre processeur.
‫Et c'est tout à fait bien parce que sinon ce serait assez lourd pour le processeur s'il devait fonctionner tout le temps et
‫faire des trucs tout le temps ou un travail lourd.
‫Mais généralement, essayez simplement de tirer, il dit simplement, d'accord, s'il n'y a rien ou s'il y a assez d'espace pour moi pour
‫exécuter un fil ou créer une menace, je vais le faire et je vais exécuter les choses qui doivent
‫être terminé.
‫Soit dit en passant, les menaces du pool de menaces gérées sont des menaces d'arrière-plan.
‫C'est leur menace est l'arrière-plan.
‫La propriété est vraie.
‫Nous n'avons donc jamais vu cela auparavant.
‫Mais si je crée une menace comme ça.
‫Alors ici, permettez-moi d'obtenir cette nouvelle menace d'ici.
‫Et si je veux mettre cela en arrière-plan, je peux le faire.
‫Donc son background est égal à, par exemple.
‫C'est ainsi que je peux définir ce fil sur votre arrière-plan et dans la file d'attente dans ce pool de threads.
‫Q Il n'y a que des menaces de fond.
‫Et l'autre point à considérer est lorsque la menace de réutilisation est une menace, ce que nous avons vu ici,
‫donc cela réduit la menace, c'est que nous avons vu cette menace gérée ID.
‫Il a été beaucoup réutilisé, puis le pool de menaces n'efface pas les données dans le stockage local des menaces.
‫Par conséquent, lorsqu'une méthode examine la menace, le stockage local, les valeurs qu'elle trouve peuvent provenir d'une utilisation antérieure de
‫la menace du pool de menaces.
‫C'est donc quelque chose que nous devons considérer.
‫Je vais partager un lien avec vous.
‫Nous pouvons en savoir plus sur les pools de menaces et les généralités.