Questions sur les pools de threads pouvant être rencontrées lors des entretiens PHP

Cet article vous présente les problèmes de pool de threads qui peuvent être rencontrés lors de l'entretien. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Avant-propos

Nous rencontrons souvent des questions sur le multi-threading et les pools de threads lors des entretiens. Comment y répondre ? Aujourd'hui, nous allons découvrir le pool de threads en Java.

Qu'est-ce qu'un pool de threads ?

Le pool de threads fait référence à la création d'un ensemble de threads lors de l'initialisation d'une application multithread, puis à la réutilisation de ces threads lorsque de nouvelles tâches doivent être effectuées à la place. de créer un nouveau fil. Le nombre de threads dans un pool de threads dépend généralement entièrement de la quantité de mémoire disponible et des besoins de l'application. Il est cependant possible d'augmenter le nombre de threads disponibles. Chaque thread du pool de threads se voit attribuer une tâche. Une fois la tâche terminée, le thread retourne dans le pool et attend la prochaine tâche assignée.

Pour parler franchement, il s'agit d'une collection de threads qui exécute plusieurs threads pour une application.

Pourquoi avons-nous besoin d’un pool de threads ?

En utilisant le pool de threads, j'ai actuellement résolu le problème :

• Utilisez le pool de threads pour obtenir plusieurs reprises dans une vidéo, économisant ainsi argent Cela a pris du temps et des ressources

• Le serveur d'arrière-plan ne prend pas en charge le téléchargement de plusieurs images, nous utilisons donc le pool de threads pour télécharger plusieurs images, réduisant ainsi le temps de téléchargement

Le rendu est le suivant :

Avant le téléchargement : 9 photos prendront au moins 3 secondes, utilisez Après l'optimisation du pool de threads, 9 images prennent 1 seconde.

L'utilisation de threads dans des applications multithread est nécessaire pour les raisons suivantes :

• 1. Réduit le nombre de threads créés et détruits, chaque thread de travail peut être réutilisé pour effectuer plusieurs tâches.

• 2. Vous pouvez ajuster le nombre de threads de travail dans le pool de threads en fonction de la capacité du système pour éviter que le serveur ne soit épuisé en raison d'une consommation excessive de mémoire (chaque thread nécessite environ 1 Mo de plus de threads sont ouverts, plus de mémoire est consommée et éventuellement elle plante).

1. Les pools de threads améliorent le temps de réponse d'une application. Étant donné que les threads du pool de threads sont prêts et attendent de se voir attribuer des tâches, l'application peut les utiliser directement sans créer de nouveau thread.

2. Le pool de threads évite au CLR la surcharge liée à la création d'un thread complet pour chaque tâche de courte durée et peut récupérer des ressources une fois la tâche terminée.

3. Le pool de threads optimise les tranches de temps des threads en fonction des processus actuellement en cours d'exécution dans le système.

4. Le pool de threads nous permet de démarrer plusieurs tâches sans définir de propriétés pour chaque thread.

5. Le pool de threads nous permet de transmettre une référence d'objet contenant des informations d'état pour les paramètres du programme de la tâche en cours d'exécution.

6. Le pool de threads peut être utilisé pour résoudre le problème de la limitation du nombre maximum de threads pour traiter une requête spécifique.

Pour apaiser le vieux Fafafa

Le rôle du pool de threads :

Le rôle du Le pool de threads consiste à limiter l'exécution dans le système. Le nombre de threads.
Selon l'environnement du système, le nombre de threads peut être défini automatiquement ou manuellement pour obtenir le meilleur effet de fonctionnement ; moins de ressources système seront gaspillées, et davantage entraînera une congestion et une inefficacité du système. Utilisez le pool de threads pour contrôler le nombre de threads, et d'autres threads font la queue. Une fois qu'une tâche est exécutée, la tâche la plus en avant dans la file d'attente est prise et l'exécution commence. S'il n'y a aucun processus en attente dans la file d'attente, cette ressource du pool de threads est en attente. Lorsqu'une nouvelle tâche doit être exécutée, s'il y a des threads de travail en attente dans le pool de threads, elle peut commencer à s'exécuter, sinon elle entre dans la file d'attente ;

Inconvénients du fil unique

Donnez-moi un exemple

new Thread(new Runnable() {

@Override
public void run() {
   paPaPaYourGridFriend();
}
}).start();

Dites les choses importantes trois fois ! ! !

Si vous utilisez toujours un nouveau Thread pour effectuer une tâche asynchrone, vous êtes donc Out !
Si vous utilisez toujours un nouveau Thread pour effectuer une tâche asynchrone, vous êtes donc Out !
Si vous utilisez toujours un nouveau Thread pour effectuer une tâche asynchrone, vous êtes donc Out !

Les inconvénients sont les suivants :

• a Chaque fois qu'un nouveau Thread crée un objet, les performances sont médiocres.

• b. Les threads manquent de gestion unifiée, il peut y avoir un nombre illimité de nouveaux threads, se faire concurrence et occuper trop de ressources système, provoquant des plantages ou un MOO.

• c. Manque de fonctions supplémentaires, telles que l'exécution planifiée, l'exécution périodique et l'interruption des threads.

Pool de threads Java

1. newSingleThreadExecutor

Créez un pool de threads à un seul thread. Ce pool de threads n'a qu'un seul thread fonctionnel, ce qui équivaut à un seul thread exécutant toutes les tâches en série. Si le seul thread se termine anormalement, un nouveau thread le remplacera. Ce pool de threads garantit que toutes les tâches sont exécutées dans l'ordre dans lequel elles sont soumises.

2.newFixedThreadPool

创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

3. newCachedThreadPool

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，

那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

4.newScheduledThreadPool

创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

newSingleThreadExecutor

  private void TextnewSingleThreadExecutor(){
        ExecutorService pool = Executors. newSingleThreadExecutor();

        MyTask1 task1 =   new MyTask1();
        MyTask2 task2 =   new MyTask2();
        MyTask3 task3 =   new MyTask3();

//        pool.execute(task1);
//        pool.execute(task2);
//        pool.execute(task3);

        new Thread(task1).start();
        new Thread(task2).start();
        new Thread(task3).start();
    }

    private class MyTask1 implements Runnable{
        @Override
        public void run() {
            //循环输出
            for(int i = 0; i <h5>ScheduledExecutorService</h5><p><img src="https://segmentfault.com/img/remote/1460000015702768" alt=" " title=" "><br></p><h5>newFixedThreadPool</h5><p><img src="https://segmentfault.com/img/remote/1460000015702769" alt=" " title=" "></p><h5><img src="https://segmentfault.com/img/remote/1460000015702770" alt=" " title=" "></h5><p   style="max-width:90%"><strong>newCachedThreadPool</strong></p><p><img src="https://segmentfault.com/img/remote/1460000015702771" alt=" " title=" "><br></p><h6>相比new Thread，Java提供的四种线程池的好处在于：</h6>

• a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。

• b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。

• c. 提供定时执行、定期执行、单线程、并发数控制等功能。

线程池真的是太好用了，如果在项目中通过线程池管理线程，，你将会发现其中的诸多优势！

阅读更多

20+个很棒的Android开源项目

2018年Android面试题含答案--适合中高级（下）一份完整的Android Studio搭建Flutter教程[](http://mp.weixin.qq.com/s?__b...

深入了解JAVA的线程中断方法经验之总结

子线程为什么不能更新UI线程详解

相信自己，没有做不到的，只有想不到的

相关推荐：

php如何连接数据库的方法

PHP中http的数据库是如何进行验证登录

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!