Présenter les caractéristiques de fonctionnement du pool de threads en Java avec des exemples

Quelle est la raison pour laquelle nous devons utiliser un pool de threads ?

Personnellement, je pense que la raison principale est la suivante : il y a beaucoup de tâches qui doivent être traitées en peu de temps.

Avantages de l'utilisation d'un pool de threads :

1. Réduisez le temps passé à créer et à détruire les threads et la surcharge des ressources système
2. Si vous n'utilisez pas de pool de threads, le système peut créer un grand nombre de threads et consommer toute la mémoire système

<.>Voici plusieurs pools de threads fournis avec Java :

1. newFixedThreadPool Créez un pool de threads avec un nombre spécifié de threads de travail.

Un thread de travail est créé chaque fois qu'une tâche est soumise. Si le nombre de threads de travail atteint le nombre maximum initial du pool de threads, la tâche soumise est stockée dans la file d'attente du pool.

2. newCachedThreadPool crée un pool de threads pouvant être mis en cache.

Les caractéristiques de ce type de pool de threads sont :

1). Il n'y a quasiment aucune limite sur le nombre de threads de travail créés (en fait, il y a une limite, le nombre est Interger). . MAX_VALUE), afin qu'il puisse être déplacé de manière flexible. Ajoutez des threads au pool de threads.

2). Si aucune tâche n'est soumise au pool de threads pendant une longue période, c'est-à-dire si le thread de travail est inactif pendant la durée spécifiée (la valeur par défaut est 1 minute), le thread de travail se terminera automatiquement. Après la résiliation, si vous soumettez une nouvelle tâche, le pool de threads recréera un thread de travail.

3. newSingleThreadExecutor crée un exécuteur monothread, c'est-à-dire qu'il crée uniquement un thread de travail unique pour effectuer des tâches si ce thread se termine anormalement, un autre le remplacera pour assurer une exécution séquentielle (je pense que c'est le sien). caractéristiques).

La plus grande caractéristique d'un seul thread de travail est qu'il peut garantir l'exécution de diverses tâches de manière séquentielle, et aucun thread multiple ne sera actif à un moment donné.

4. newScheduleThreadPool crée un pool de threads de longueur fixe et prend en charge l'exécution de tâches planifiées et périodiques, similaire à Timer.

Résumé :

1.FixedThreadPool est un pool de threads typique et excellent. Il présente les avantages d'améliorer l'efficacité du programme et d'économiser la surcharge lors de la création de threads. Mais lorsque le pool de threads est inactif, c'est-à-dire lorsqu'il n'y a aucune tâche exécutable dans le pool de threads, il ne libérera pas les threads de travail et occupera également certaines ressources système.

2. La caractéristique de CachedThreadPool est que lorsque le pool de threads est inactif, c'est-à-dire lorsqu'il n'y a aucune tâche exécutable dans le pool de threads, il libère le thread de travail, libérant ainsi les ressources occupées par le thread de travail. Cependant, lorsqu'une nouvelle tâche apparaît, un nouveau thread de travail doit être créé, ce qui nécessite une certaine surcharge du système. De plus, lorsque vous utilisez CachedThreadPool, vous devez faire attention au contrôle du nombre de tâches, sinon, en raison d'un grand nombre de threads exécutés en même temps, le système pourrait être paralysé.

Exemples d'utilisation du pool de threads Java ThreadPoolExecutor

package com.sondon.mayi.jpool; 
  
import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.Callable; 
import java.util.concurrent.ExecutionException; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 
  
public class JPoolLearn { 
  
 private static int produceTaskSleepTime = 3; 
 private static int produceTaskMaxNumber = 20; 
   
 public void testThreadPoolExecutor(){ 
  /* 
   * ThreadPoolExecutor( 
   * int corePoolSize, //线程池维护线程的最少数量 
   * int maximumPoolSize, //线程池维护线程的最大数量 
   * long keepAliveTime, //线程池维护线程所允许的空闲时间 
   * TimeUnit unit, //线程池维护线程所允许的空闲时间的单位 
   * BlockingQueue<Runnable> workQueue, //线程池所使用的缓冲队列 
   * RejectedExecutionHandler handler //线程池对拒绝任务的处理策略 ) 
   */ 
  ThreadPoolExecutor threadPool = new ThreadPoolExecutor( 
    5, 
    10, 
    3, 
    TimeUnit.SECONDS, 
    new ArrayBlockingQueue<Runnable>(10), 
    new ThreadPoolExecutor.DiscardOldestPolicy() 
    ); 
  
  for (int i = 1; i <= produceTaskMaxNumber; i++) { 
   try { 
    // 产生一个任务，并将其加入到线程池 
    String task = "task---" + i; 
    threadPool.execute(new ThreadPoolTask(task)); 
    System.out.println("activeCount :"+ threadPool.getActiveCount()); 
    // 便于观察，等待一段时间 
    Thread.sleep(produceTaskSleepTime); 
   } catch (Exception e) { 
    e.printStackTrace(); 
   } 
  } 
    
  //查看当前的线程池状况 
  while(true){ 
   try { 
    Thread.sleep(3000); 
    System.out.println("pool size :"+threadPool.getPoolSize());//线程池中线程数量 
    System.out.println("active count :"+threadPool.getActiveCount());//线程池中活动的线程数量 
   } catch (InterruptedException e) { 
    e.printStackTrace(); 
   } 
  } 
 } 
  
 /** 
  * 
  * @Author 蔡文锋 
  * @Data_Time 2015年7月25日 下午4:06:28 
  * @Description { 测试不同线程池模式 } 
  */ 
 public void testNewCachedThreadPool(){ 
  ThreadPoolExecutor threadPool=(ThreadPoolExecutor) Executors.newCachedThreadPool(); 
//  ThreadPoolExecutor threadPool=(ThreadPoolExecutor) Executors.newFixedThreadPool(100); 
//  ThreadPoolExecutor threadPool=(ThreadPoolExecutor) Executors.newScheduledThreadPool(100); 
//  ThreadPoolExecutor threadPool=(ThreadPoolExecutor) Executors.newSingleThreadExecutor(); 
  try { 
  for (int i = 0; i < 100; i++) { 
   // 产生一个任务，并将其加入到线程池 
   String task = "task---" + i; 
   threadPool.execute(new ThreadPoolTask(task)); 
   System.out.println("activeCount :"); 
   // 便于观察，等待一段时间 
   Thread.sleep(produceTaskSleepTime); 
     
   } 
  } catch (InterruptedException e) { 
   e.printStackTrace(); 
  } 
  //查看当前的线程池状况 
  while(true){ 
   try { 
    Thread.sleep(3000); 
    System.out.println("pool size :"+threadPool.getPoolSize());//线程池中线程数量 
    System.out.println("active count :"+threadPool.getActiveCount());//线程池中活动的线程数量 
   } catch (InterruptedException e) { 
    e.printStackTrace(); 
   } 
  } 
 } 
   
 /** 
  * 
  * @Author 蔡文锋 
  * @Data_Time 2015年7月25日 下午4:06:58 
  * @Description { 测试callable与runable方法的区别 } 
  */ 
 public void testNewCachedThreadPool_callable(){ 
  ExecutorService es=Executors.newFixedThreadPool(10); 
  try { 
     
//   String result=es.submit(new MyCallable<String>()).get(); 
//   System.out.println("callable result :"+result); 
     
   String result=(String) es.submit(new ThreadPoolTask("")).get(); 
   System.out.println("runable result :"+result); 
     
  } catch (InterruptedException | ExecutionException e) { 
   e.printStackTrace(); 
  } 
 } 
   
   
 public static void main(String[] args) { 
  new JPoolLearn().testNewCachedThreadPool(); 
 } 
} 
  
  
  
/** 
 * 线程池执行的任务 
 */ 
class ThreadPoolTask implements Runnable { 
 private static int consumeTaskSleepTime = 2000; 
 // 保存任务所需要的数据 
 private Object threadPoolTaskData; 
  
 ThreadPoolTask(Object tasks) { 
  this.threadPoolTaskData = tasks; 
 } 
  
 public void run() { 
  System.out.println("start .." + threadPoolTaskData); 
  try { 
   // Sleep 2秒 模拟耗时操作 
   Thread.sleep(consumeTaskSleepTime); 
  } catch (Exception e) { 
   e.printStackTrace(); 
  } 
  threadPoolTaskData = null; 
 } 
  
 public Object getTask() { 
  return this.threadPoolTaskData; 
 } 
} 
  
/** 
 * 
 * @Project : JPool 
 * @Package : com.sondon.mayi.jpool 
 * @Class : MyCallable 
 * @param <T> 
 */
class MyCallable<T> implements Callable<T>{ 
   
 @Override
 public T call() throws Exception { 
   System.out.println("开始执行Callable"); 
   return (T) "测试callable接口"; 
  } 
}

Pour plus d'exemples pour présenter les caractéristiques de fonctionnement des pools de threads en Java, veuillez faire attention au site Web PHP chinois pour les articles connexes !