Stellen Sie anhand von Beispielen die Arbeitseigenschaften des Thread-Pools in Java vor

Was ist der Grund, warum wir den Thread-Pool verwenden müssen?

Ich persönlich denke, der Hauptgrund ist: die Anzahl der Aufgaben, die in kurzer Zeit bearbeitet werden müssen

Vorteile der Verwendung eines Thread-Pools:

1 . Reduzieren Sie den Zeitaufwand für das Erstellen und Zerstören von Threads und den Systemressourcenaufwand
2. Wenn Sie keinen Thread-Pool verwenden, kann dies dazu führen, dass das System eine große Anzahl von Threads erstellt und den gesamten Systemspeicher verbraucht

Im Folgenden sind mehrere Thread-Pools aufgeführt, die mit Java geliefert werden:

1. newFixedThreadPool Erstellen Sie einen Thread-Pool mit einer angegebenen Anzahl von Arbeitsthreads.

Ein Arbeitsthread wird immer dann erstellt, wenn eine Aufgabe übermittelt wird. Wenn die Anzahl der Arbeitsthreads die anfängliche maximale Anzahl des Thread-Pools erreicht, wird die übermittelte Aufgabe in der Poolwarteschlange gespeichert.

2. newCachedThreadPool erstellt einen zwischenspeicherbaren Thread-Pool.

Die Merkmale dieser Art von Thread-Pool sind:

1 Es gibt fast keine Begrenzung für die Anzahl der erstellten Arbeitsthreads (tatsächlich gibt es eine Begrenzung, die Anzahl ist ganzzahlig). . MAX_VALUE), damit Threads flexibel zum Thread-Pool verschoben werden können.

2). Wenn längere Zeit keine Aufgabe an den Thread-Pool gesendet wird, d. h. wenn der Worker-Thread für die angegebene Zeit inaktiv ist (Standard ist 1 Minute), wird der Worker-Thread automatisch beendet. Wenn Sie nach der Beendigung eine neue Aufgabe senden, erstellt der Thread-Pool einen Arbeitsthread neu.

3. newSingleThreadExecutor erstellt einen Single-Threaded-Executor, d Merkmal).

Das größte Merkmal eines einzelnen Arbeitsthreads besteht darin, dass er die Ausführung verschiedener Aufgaben nacheinander gewährleisten kann und zu keinem Zeitpunkt mehrere Threads aktiv sind.

4. newScheduleThreadPool erstellt einen Thread-Pool fester Länge und unterstützt die geplante und periodische Aufgabenausführung, ähnlich wie Timer.

Zusammenfassung:

1. FixedThreadPool ist ein typischer und ausgezeichneter Thread-Pool. Er bietet die Vorteile eines Thread-Pools, der die Programmeffizienz verbessert und den Overhead beim Erstellen von Threads spart. Wenn der Thread-Pool jedoch inaktiv ist, dh wenn sich keine ausführbaren Aufgaben im Thread-Pool befinden, werden die Arbeitsthreads nicht freigegeben und auch bestimmte Systemressourcen belegt.

2. Das Merkmal von CachedThreadPool besteht darin, dass der Arbeitsthread freigegeben wird, wenn der Thread-Pool inaktiv ist, dh wenn sich keine ausführbaren Aufgaben im Thread-Pool befinden, wodurch die vom Arbeitsthread belegten Ressourcen freigegeben werden. Wenn jedoch eine neue Aufgabe erscheint, muss ein neuer Arbeitsthread erstellt werden, was einen gewissen Systemaufwand erfordert. Darüber hinaus müssen Sie bei der Verwendung von CachedThreadPool darauf achten, die Anzahl der Aufgaben zu kontrollieren. Andernfalls kann das System aufgrund einer großen Anzahl gleichzeitig ausgeführter Threads lahmgelegt werden.

Nutzungsbeispiele für den Java-Thread-Pool 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接口"; 
  } 
}

Weitere Beispiele zur Einführung in die Arbeitseigenschaften von Thread-Pools in Java finden Sie auf der chinesischen PHP-Website für verwandte Artikel!