Exemple d'analyse de code pour une compréhension approfondie des paramètres Java ThreadPoolExecutor

Cet article présente principalement des informations pertinentes pour une compréhension approfondie des paramètres de Java ThreadPoolExecutor. Les amis qui en ont besoin peuvent se référer à

Compréhension approfondie des paramètres de Java ThreadPoolExecutor.

1. Utilisez les exécuteurs pour créer un pool de threads. Bien sûr, les exécuteurs utilisent également différents paramètres pour new ThreadPoolExecutor

1. newFixedThreadPool()

Créez un pool de threads avec un nombre fixe de threads. Puisque LinkedBlockingQueue est utilisé, maximumPoolSize est inutile Lorsque corePoolSize est plein, il est ajouté à LinkedBlockingQueue

queue. Chaque fois qu'un thread termine son exécution, prenez-en un dans la file d'attente LinkedBlockingQueue. Cela crée donc un pool de threads de taille fixe.

2.newSingleThreadPool()

 public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                   0L, TimeUnit.MILLISECONDS,
                   new LinkedBlockingQueue<Runnable>());
  }
 public ThreadPoolExecutor(int corePoolSize,
               int maximumPoolSize,
               long keepAliveTime,
               TimeUnit unit,
               BlockingQueue<Runnable> workQueue) {
   this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
       Executors.defaultThreadFactory(), defaultHandler);
  }

Créez un pool de threads avec un nombre de threads de 1. Puisque LinkedBlockingQueue est utilisé, maximumPoolSize est inutile. 1 indique le nombre de threads. La taille est 1. Lorsqu'il est plein, il est mis dans la file d'attente. Lorsque l'exécution est terminée, un est retiré de la file d'attente.

3.newCachedThreadPool()

 public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
      (new ThreadPoolExecutor(1, 1,
                  0L, TimeUnit.MILLISECONDS,
                  new LinkedBlockingQueue<Runnable>()));
  }

Créez un pool de threads pouvant être mis en mémoire tampon. Aucune limite de taille. Puisque corePoolSize est 0, la tâche sera placée dans la file d'attente SynchronousQueue. SynchronousQueue ne peut stocker qu'une taille de 1, donc un nouveau thread sera démarré immédiatement. Puisque la taille maximale de PoolSize est Integer.MAX_VALUE, la taille peut être considérée comme étant de 2147483647. . Limité par la taille de la mémoire.

2. Utilisez ThreadPoolExecutor pour créer un pool de threads

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                   60L, TimeUnit.SECONDS,
                   new SynchronousQueue<Runnable>());
  }
public ThreadPoolExecutor(int corePoolSize,
             int maximumPoolSize,
             long keepAliveTime,
             TimeUnit unit,
             BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
       Executors.defaultThreadFactory(), defaultHandler);
  }

Constructeur

de ThreadPoolExecutor

Paramètres : 1. corePoolSize Le nombre de threads principaux. Lorsque le nombre de threads

 public ThreadPoolExecutor(int corePoolSize,
               int maximumPoolSize,
               long keepAliveTime,
               TimeUnit unit,
               BlockingQueue<Runnable> workQueue,
               ThreadFactory threadFactory,
               RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
      maximumPoolSize <= 0 ||
      maximumPoolSize < corePoolSize ||
      keepAliveTime < 0)
      throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
      throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
  }

2. maximumPoolSize Le nombre maximum de threads>. = corePoolSize, les threads seront créés. Mettez runnable dans workQueue

3. keepAliveTime maintient le temps de survie lorsque le nombre de threads est supérieur à corePoolSize, la durée maximale qu'un thread inactif peut maintenir.

4. unité de temps

5. workQueue contient la file d'attente de blocage des tâches

6. threadFactory crée une fabrique de threads

7. stratégie de rejet du gestionnaire

Séquence d'exécution de la tâche :

1. Lorsque le nombre de threads est inférieur à corePoolSize, créez un thread pour exécuter la tâche.

2. Lorsque le nombre de threads est supérieur ou égal à corePoolSize et que la workQueue n'est pas pleine, mettez-la dans la workQueue

3. Le nombre de threads est supérieur ou égal à corePoolSize et lorsque la workQueue est pleine, une nouvelle tâche sera créée et un thread sera exécuté. Le nombre total doit être inférieur à maximumPoolSize

4. Lorsque le nombre total de threads est égal à maximumPoolSize et à workQueue. est plein, l'exécution rejetée du gestionnaire est exécutée. C'est la stratégie de rejet.

ThreadPoolExecutor a quatre politiques de rejet par défaut :

1. ThreadPoolExecutor.AbortPolicy() directement

lève une exception RejectedExecutionException

2. ThreadPoolExecutor.CallerRunsPolicy() Appeler directement la méthode d'exécution et bloquer l'exécution

3. ThreadPoolExecutor.DiscardPolicy() Supprimer directement les tâches suivantes

4. ThreadPoolExecutor.DiscardOldestPolicy() Supprimer le chef de file d'attente De bien sûr, la tâche

peut

hériter de

RejectedExecutionHandler pour écrire la stratégie de rejet

.

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!