Cadre de pool de threads Java

Cet article présente principalement les connaissances pertinentes du framework de pool de threads Java. Il a une très bonne valeur de référence, jetons-y un coup d'œil avec l'éditeur ci-dessous

1 Diagramme de structure du pool de threads

2. Exemple

Définir l'interface du thread

public class MyThread extends Thread {
 @Override
 publicvoid run() {
 System.out.println(Thread.currentThread().getName() + "正在执行");
 }
}

1 : newSingleThreadExecutor

ExecutorService pool = Executors. newSingleThreadExecutor();
 Thread t1 = new MyThread();
 Thread t2 = new MyThread();
 Thread t3 = new MyThread();
 //将线程放入池中进行执行
 pool.execute(t1);
 pool.execute(t2);
 pool.execute(t3);
 //关闭线程池
 pool.shutdown();

Résultat d'entrée :

pool-1-thread-1正在执行
pool-1-thread-1正在执行
pool-1-thread-1正在执行

2 : newFixedThreadPool

ExecutorService pool = Executors.newFixedThreadPool(3);
Thread t1 = new MyThread();
 Thread t2 = new MyThread();
 Thread t3 = new MyThread();
 Thread t4 = new MyThread();
 Thread t5 = new MyThread();
 //将线程放入池中进行执行
 pool.execute(t1);
 pool.execute(t2);
 pool.execute(t3);
 pool.execute(t4);
 pool.execute(t5);
pool.shutdown();

Résultat d'entrée :

pool-1-thread-1正在执行
pool-1-thread-2正在执行
pool-1-thread-1正在执行
pool-1-thread-2正在执行

3 :newCachedThreadPool

ExecutorService pool = Executors.newCachedThreadPool();
 Thread t1 = new MyThread();
 Thread t2 = new MyThread();
 Thread t3 = new MyThread();
 Thread t4 = new MyThread();
 Thread t5 = new MyThread();
 //将线程放入池中进行执行
 pool.execute(t1);
 pool.execute(t2);
 pool.execute(t3);
 pool.execute(t4);
 pool.execute(t5);
 //关闭线程池
 pool.shutdown();

Résultat d'entrée :

pool-1-thread-2正在执行
pool-1-thread-4正在执行
pool-1-thread-3正在执行
pool-1-thread-1正在执行
pool-1-thread-5正在执行

4 :ScheduledThreadPoolExecutor

ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
pool.scheduleAtFixedRate(new Runnable() {//每隔一段时间就触发异常
  @Override
  public void run() {
   //throw new RuntimeException();
   System.out.println("================");
  }
 }, 1000, 2000, TimeUnit.MILLISECONDS);
pool.scheduleAtFixedRate(new Runnable() {//每隔一段时间打印系统时间，证明两者是互不影响的
  @Override
  public void run() {
   System.out.println("+++++++++++++++++");
  }
 }, 1000, 2000, TimeUnit.MILLISECONDS);

Résultat d'entrée :

================
+++++++++++++++++
+++++++++++++++++
+++++++++++++++++

3. Paramètres de base du pool de threads

corePoolSize : dans le pool Nombre de threads principaux

maximumPoolSize : Le nombre maximum de threads autorisés dans le pool.

keepAliveTime : lorsque le nombre de threads est supérieur au nombre de threads principaux, il s'agit du temps maximum pendant lequel les threads inactifs en excès attendent de nouvelles tâches avant de se terminer.

unit : L'unité de temps du paramètre keepAliveTime.

workQueue : file d'attente utilisée pour conserver les tâches avant leur exécution. Cette file d'attente contient uniquement les tâches Runnable soumises par la méthode d'exécution.

threadFactory : Factory utilisée par l'exécuteur pour créer de nouveaux threads.

handler : gestionnaire utilisé lorsque l'exécution est bloquée en raison d'un dépassement de la portée du thread et de la capacité de la file d'attente.

ThreadPoolExecutor : l'implémentation sous-jacente de la classe Executors.

3.1 Mécanisme de mise en file d'attente des tâches

SynchonousQueue : file d'attente synchrone, la file d'attente est directement soumise au thread pour exécution sans les maintenir à ce moment. , le pool de threads est généralement illimité

LinkedBlockingQueue : file d'attente illimitée Lorsque le nombre de threads du pool de threads atteint le nombre maximum, les nouvelles tâches attendent dans la file d'attente pour être exécutées, ce qui peut entraîner une extension infinie de la file d'attente

ArrayBlockingQueue : la file d'attente limitée aide à prévenir l'épuisement des ressources. Une fois la limite supérieure atteinte, les nouvelles tâches peuvent être perdues

Remarque : L'utilisation de newSingleThreadExecutor et newFixedThreadPool est LinkedBlockingQueue

newCachedThreadPool utilise SynchonousQueue

newScheduledThreadPool utilise DelayedWorkQueue

3.2 Processus d'exécution de thread

3.3 Détermination de la taille des threads :

CPU gourmand : ouvrez le moins de threads possible, le nombre optimal de threads est Ncpu 1

io-intensif : plusieurs threads, 2Ncpu

Mixte : selon la situation, peut être divisé en io-intensif et cou-intensif

Plus Frameworks de pool de threads Java Pour les articles connexes, veuillez faire attention au site Web PHP chinois !