线程池的处理策略(ThreadPoolExecutor)

Posted 2021-04-06 龙旋

1.什么是线程池？
由于线程的运行的速度太快，可能线程的销毁时间比运行的时间还要长，所以出现线程池可以在池里面先定义一定数量的线程，等要用的时候再从线程池里面进行获取，用完之后再统一进行销毁。

2.线程池的处理策略

图解析：

1.先在线程池里面定义5个核心线程，当有任务来的时候，会由核心线程进行处理任务。

2.再有任务来的时候，此时核心线程正在处理任务，所以会将来的任务放在消息队列（阻塞队列）中(最多装10个)

3.消息队列放满的时候，还有任务到来，此时会请外来的线程进行处理，外来的线程是有限的（由maxmumPoolSize和corePoolSize决定）

4.当核心线程，消息队列，还有外来线程都放满了，此时还有任务到来的时候，线程池会有5种处理策略：抛异常，不做任何处理，移除队列中的某个，main线程执行这个任务，自定义.

3.构建线程池的源码：

 
   
   
 

  
    
    
  
 public ThreadPoolExecutor(int corePoolSize, //核心线程数
  
    
    
  
                          int maximumPoolSize,//最大线程数（核心线程+外来线程）
  
    
    
  
                          long keepAliveTime,//外来线程的存活时间
  
    
    
  
                          TimeUnit unit,//存活时间的单位
  
    
    
  
                          BlockingQueue<Runnable> workQueue,//消息队列
  
    
    
  
                          ThreadFactory threadFactory,//线程工厂
  
    
    
  
                          RejectedExecutionHandler handler)//当核心线程，消息队列，还有外来线程都放满后的处理机制
 
   
   
 

4.演示代码：

 
   
   
 

  
    
    
  
import java.util.concurrent.BlockingQueue;
  
    
    
  
import java.util.concurrent.ExecutorService;
  
    
    
  
import java.util.concurrent.Executors;
  
    
    
  
import java.util.concurrent.LinkedBlockingQueue;
  
    
    
  
import java.util.concurrent.RejectedExecutionHandler;
  
    
    
  
import java.util.concurrent.ThreadFactory;
  
    
    
  
import java.util.concurrent.ThreadPoolExecutor;
  
    
    
  
import java.util.concurrent.TimeUnit;
  
    
    
  


  
    
    
  
public class Main {
  
    
    
  


  
    
    
  
    public static void main(String[] args) {
  
    
    
  


  
    
    
  
        BlockingQueue blockingQueue = new LinkedBlockingQueue(10);
  
    
    
  


  
    
    
  
        ThreadFactory factory = Executors.defaultThreadFactory();
  
    
    
  


  
    
    
  
        RejectedExecutionHandler handler = new ThreadPoolExecutor.CallerRunsPolicy();// 抛异常
  
    
    
  


  
    
    
  
        // 构建线程池
  
    
    
  


  
    
    
  
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 9, 30, TimeUnit.SECONDS, blockingQueue, factory,
  
    
    
  
                handler);
  
    
    
  


  
    
    
  
        for (int i = 0; i < 30; i++) {
  
    
    
  


  
    
    
  
            int temp=i;
  
    
    
  


  
    
    
  
            executor.execute(new Runnable() {
  
    
    
  


  
    
    
  
                @Override
  
    
    
  


  
    
    
  
                public void run() {
  
    
    
  


  
    
    
  
                    System.out.println(temp+":"+Thread.currentThread().getName());
  
    
    
  


  
    
    
  
                    try {
  
    
    
  


  
    
    
  
                        Thread.sleep(5000);
  
    
    
  


  
    
    
  
                    } catch (InterruptedException e) {
  
    
    
  


  
    
    
  
                        e.printStackTrace();
  
    
    
  
                    }
  
    
    
  


  
    
    
  
                }
  
    
    
  
            });
  
    
    
  
        }
  
    
    
  
//        int poolSize = executor.getPoolSize();
  
    
    
  


  
    
    
  
//        System.out.println("poolSize:"+poolSize);
  
    
    
  


  
    
    
  
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(3);
  
    
    
  


  
    
    
  
//        newFixedThreadPool.execute(command);
  
    
    
  


  
    
    
  
        Executors.newSingleThreadExecutor();
  
    
    
  


  
    
    
  
    }
  
    
    
  
}