Java 线程池ThreadPoolExecutor基本使用方法

亦凉 2022-03-25 10:10 347阅读 0赞

## 为什么用线程池 ##

*  系统需要处理非常多的执行时间很短的请求，如果每一个请求都开启一个新线程的话，系统就要不断的进行线程的创建和销毁，有时花在创建和销毁线程上的时间会比线程真正执行的时间还长。
 *  通过重用线程池中的线程，来减少每个线程创建和销毁的性能开销。
 *  对线程进行一些维护和管理，比如定时开始，周期执行，并发数控制。

## ThreadPoolExecutor解析 ##

ThreadPoolExecutor是线程的实现，通过构造方法一系列参数来配置不同的线程，常用的方法有四个。  
![在这里插入图片描述][20190120100836469.jpg]

*  corePoolSize  
    核心线程数，默认情况下核心线程会一直存活，即使处于闲置状态也不会受存keepAliveTime限制。除非将allowCoreThreadTimeOut设置为true。
 *  maximumPoolSize  
    线程池所能容纳的最大线程数。超过这个数的线程将被阻塞。当任务队列为没有设置大小的LinkedBlockingDeque时，这个值无效。
 *  keepAliveTime  
    非核心线程的闲置超时时间，超过这个时间就会被回收。
 *  unit  
    指定keepAliveTime的单位，如TimeUnit.SECONDS。当将allowCoreThreadTimeOut设置为true时对corePoolSize生效。
 *  workQueue  
    线程池中的任务队列.  
    常用的有三种队列，SynchronousQueue,LinkedBlockingDeque,ArrayBlockingQueue。
 *  threadFactory  
    线程工厂，提供创建新线程的功能。ThreadFactory是一个接口，只有一个方法。

## 线程池规则 ##

1.  下面都假设任务队列没有大小限制：
    
    1.  如果线程数量<=核心线程数量，那么直接启动一个核心线程来执行任务，不会放入队列中。
    2.  如果线程数量>核心线程数，但<=最大线程数，并且任务队列是LinkedBlockingDeque的时候，超过核心线程数量的任务会放在任务队列中排队。
    3.  如果线程数量>核心线程数，但<=最大线程数，并且任务队列是SynchronousQueue的时候，线程池会创建新线程执行任务，这些任务也不会被放在任务队列中。这些线程属于非核心线程，在任务完成后，闲置时间达到了超时时间就会被清除。
    4.  如果线程数量>核心线程数，并且>最大线程数，当任务队列是LinkedBlockingDeque，会将超过核心线程的任务放在任务队列中排队。也就是当任务队列是LinkedBlockingDeque并且没有大小限制时，线程池的最大线程数设置是无效的，他的线程数最多不会超过核心线程数。
    5.  如果线程数量>核心线程数，并且>最大线程数，当任务队列是SynchronousQueue的时候，会因为线程池拒绝添加任务而抛出异常。
2.  任务队列大小有限时
    
    1.  当LinkedBlockingDeque塞满时，新增的任务会直接创建新线程来执行，当创建的线程数量超过最大线程数量时会抛异常。
    2.  SynchronousQueue没有数量限制。因为他根本不保持这些任务，而是直接交给线程池去执行。当任务数量超过最大线程数时会直接抛异常。
3.  如何确定线程池数量
    
    1.  CPU密集型任务配置尽可能少的线程池数量：CPU核数+1
    2.  IO密集型任务配置尽可能多的线程池数量：CPU核数\*2

## 示例 ##

public class Test { 
         public static void main(String[] args) {    
         	ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS， new ArrayBlockingQueue<Runnable>(5));          
             for(int i=0;i<15;i++){ 
                 TestTask testTask = new TestTask(i);
                 executor.execute(testTask);
                 System.out.println("线程池中线程数目："+executor.getPoolSize()+"，队列中等待执行的任务数目："+
                 executor.getQueue().size()+"，已执行玩别的任务数目："+executor.getCompletedTaskCount());
             }
             executor.shutdown();
         }
    }

class TestTask implements Runnable { 
        private int taskNum;
         
        public TestTask(int num) { 
            this.taskNum = num;
        }
         
        @Override
        public void run() { 
            System.out.println("正在执行task "+taskNum);
            try { 
                Thread.currentThread().sleep(4000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("task "+taskNum+"执行完毕");
        }
    }

## 运行结果 ##

正在执行task 0
    线程池中线程数目：1，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
    线程池中线程数目：2，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
    正在执行task 1
    线程池中线程数目：3，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
    正在执行task 2
    线程池中线程数目：4，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
    正在执行task 3
    线程池中线程数目：5，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
    正在执行task 4
    线程池中线程数目：5，队列中等待执行的任务数目：1，已执行玩别的任务数目：0
    线程池中线程数目：5，队列中等待执行的任务数目：2，已执行玩别的任务数目：0
    线程池中线程数目：5，队列中等待执行的任务数目：3，已执行玩别的任务数目：0
    线程池中线程数目：5，队列中等待执行的任务数目：4，已执行玩别的任务数目：0
    线程池中线程数目：5，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
    线程池中线程数目：6，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
    正在执行task 10
    线程池中线程数目：7，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
    正在执行task 11
    线程池中线程数目：8，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
    正在执行task 12
    线程池中线程数目：9，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
    正在执行task 13
    线程池中线程数目：10，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
    正在执行task 14
    task 3执行完毕
    task 0执行完毕
    task 2执行完毕
    task 1执行完毕
    正在执行task 8
    正在执行task 7
    正在执行task 6
    正在执行task 5
    task 4执行完毕
    task 10执行完毕
    task 11执行完毕
    task 13执行完毕
    task 12执行完毕
    正在执行task 9
    task 14执行完毕
    task 8执行完毕
    task 5执行完毕
    task 7执行完毕
    task 6执行完毕
    task 9执行完毕

[20190120100836469.jpg]: /images/20220325/a10e7a9ce9f64856bdc001ba3f1dd8b1.png