ThreadPoolExecutor如何创建线程池

Posted 2021-03-06 llllitm

一、为什么要使用线程池？

a)      减少开销。因为创建和销毁线程需要和底层操作系统交互，每个线程都去做这个操作，会浪费大量的时间，降低系统效率

b)      避免内存溢出。线程池的线程数量不会超过最大值，不使用线程池可能会造成无限制的创建线程

二、为什么不使用Executors来创建线程池

a)      Java中有自带的线程池工具Executors，但是阿里巴巴的JAVA开发手册中指明不要使用，原因如图所示。

其中原因是线程池的缓冲队列为BlockingQueue，其实现有ArrayBlockingQueue和LinkedBlockingQueue两种。当使用数组队列的时候必须指定容量，但是使用链表的队列则可以不用指明容量，将会行成一个最大容量为Integer.Max_Value的队列，而使用Executors的时候是没有指定链表长度的，因此可能会造成内存溢出。并且其中许多方法已经将参数定义好了，不能够灵活调整。因此，推荐使用ThreadPoolExecutor。

 

三、ThreadPoolExecutor如何创建

a)      我使用的构造方法是public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

corePoolSize：核心线程数，这些线程即便是在空闲的时候，也不会被关闭。

maximumPoolSize：最大线程数，当缓冲队列被装满的时候，就会开始创建新的线程，线程池中的线程数量不会超过这个值，新创建出来的线程在空闲的时候会被回收。

keepAliveTime：非核心空闲线程的存活时间。

Unit：存活时间单位。

workQueue：缓冲队列，当线程已经被全部使用，请求就会放在缓冲队列中，等待处理，其实现类为ArrayBlockingQueue和LinkedBlockingQueue，建议设置长度才不会造成内存溢出。

threadFactory：创建线程的方法，可以在里面对新建的线程做一个自定义操作。

RejectedExecutionHandler：当缓冲队列满了后，对新来的请求进行处理。可以抛弃、返回请求、重新添加到队列等操作，亦可以使用默认的策略：

1. 1. AbortPolicy：抛出异常。
   2. DiscardPolicy：直接抛弃请求。
   3. DiscardOldestPolicy：丢弃队列中最老的任务。
   4. CallerRunsPolicy：将任务分配给当前执行execute方法线程来处理。

这些参数中maximumPoolSize >= corePoolSize >0有这样的关系。

四、查看运行期间线程池的状态

ThreadPoolExecutor.getQueue().size()：当前排队线程数

ThreadPoolExecutor.getActiveCount()：当前活动线程数

ThreadPoolExecutor.getCompletedTaskCount()：执行完成线程数

ThreadPoolExecutor.getTaskCount：总线程数

五、如何关闭线程池

a)      ShutDownNow

线程池拒绝新的任务，并且关闭所有线程、线程池

b)      ShutDown

线程池拒绝新的任务，但是会等待线程池所有的任务结束后再关闭线程池

       参考https://www.cnblogs.com/qingquanzi/p/9018627.html

       在最后调用一次ThreadPoolExecutor.isTerminated()方法，该方法确保等待子线程运行完成后再退出主线程。

六、参考代码

　　获取线程池的方法

 1 public static ThreadPoolExecutor getInstence(){
 2         if (threadPool == null){
 3             synchronized (ThreadPoolExecutor.class){
 4                 if (threadPool == null){
 5                     threadPool = new ThreadPoolExecutor(
 6                             5,
 7                             10,
 8                             60,
 9                             TimeUnit.SECONDS,
10                             new ArrayBlockingQueue<>(100, true),
11                             r -> {
12                                 Thread thread = new Thread(r);
13                                 thread.setName("thread_Test");
14                                 return thread;
15                             },
16                             (r, executor) -> {
17                                 BlockingQueue<Runnable> queue = executor.getQueue();
18                                 try {
19                                     queue.put(r);
20                                 } catch (InterruptedException e) {
21                                     e.printStackTrace();
22                                 }
23                             }
24                     );
25                 }
26             }
27         }
28         return threadPool;
29     }

 1 public static void main(String[] args) {
 2         ThreadPoolExecutor threadPool = ThreadPoolUtils.getInstence();
 3         for (int i = 0; i < 1000; i++) {
 4             System.out.println("当前执行任务：：：Task"+i);
 5             threadPool.execute(() -> {
 6                 try {
 7                     Thread.sleep(1000);
 8                 } catch (InterruptedException e) {
 9                     e.printStackTrace();
10                 }
11             });
12         }
13         threadPool.shutdown();
14         while (!threadPool.isTerminated()){
15             System.out.println("当前排队线程数====="+threadPool.getQueue().size());
16             System.out.println("当前活动线程数====="+threadPool.getActiveCount());
17             System.out.println("当前完成线程数====="+threadPool.getCompletedTaskCount());
18             System.out.println("总线程数==========="+threadPool.getTaskCount());
19             try {
20                 Thread.sleep(3000);
21             } catch (InterruptedException e) {
22                 e.printStackTrace();
23             }
24         }
25     }