Qu'est-ce que le pool de threads en Java

Le pool de threads est une forme de multithreading qui ajoute des tâches à une file d'attente pendant le traitement, puis démarre automatiquement ces tâches après la création du thread. Les threads du pool de threads sont des threads d’arrière-plan. Chaque thread utilise la taille de pile par défaut, s'exécute avec la priorité par défaut et se trouve dans un appartement multithread .

Si un thread est inactif dans le code managé (par exemple en attente d'un événement), le pool de threads en insérera un autre thread de travail pour garder tous les processeurs occupés.

Si tous les threads du pool de threads restent occupés à tout moment mais que la file d'attente contient du travail en attente, le pool de threads créera un autre thread de travail après un certain temps mais le nombre de threads ne dépassera jamais le maximum. Les threads qui dépassent le maximum peuvent être mis en file d'attente, mais ils ne sont démarrés que lorsque les autres threads ont terminé. (Apprentissage recommandé : cours java)

Utilisation de quatre pools de threads en Java :

Java fournit quatre pools de threads via les exécuteurs , respectivement :

newCachedThreadPool crée un pool de threads pouvant être mis en cache. Si la longueur du pool de threads dépasse les besoins de traitement, les threads inactifs peuvent être recyclés de manière flexible. S'il n'y a pas de recyclage, un nouveau thread sera créé.

newFixedThreadPool crée un pool de threads de longueur fixe, qui peut contrôler le nombre maximum de threads simultanés qui attendent dans la file d'attente.

newScheduledThreadPool crée un pool de threads de longueur fixe qui prend en charge l'exécution de tâches planifiées et périodiques.

newSingleThreadExecutor crée un pool de threads à thread unique, qui utilisera uniquement un thread de travail unique pour exécuter les tâches, garantissant que toutes les tâches sont exécutées dans l'ordre spécifié (FIFO, LIFO, priorité).

newCachedThreadPool

Créez un pool de threads pouvant être mis en cache si la longueur du pool de threads dépasse les besoins de traitement, les threads inactifs peuvent être recyclés de manière flexible s'il n'y en a pas. recyclage, créez-en un nouveau. L'exemple de code est le suivant :

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            try {
                Thread.sleep(index * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(new Runnable() {
                public void run() {
                    System.out.println(index);
                }
            });
        }
    }
}

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!