线程池原理和实现

$1. 概述

线程池产生背景：高并发项目中常常须要同时启用大量线程，所以须要建立大量线程，而频繁的建立新线程和杀死旧线程将会大大拖慢CPU的性能，所以利用线程池一次性初始化若干线程，使用时从池中弹出线程，执行完线程池再予以回收

线程池的工做流程：主要是控制运行的线程数量，处理过程当中将任务放入队列，而后在线程建立后启动这些任务，若是线程数量超过了最大数量，超出数量的线程排队等候，等其余线程执行完毕，再从队列中取出任务执行

线程池的主要特色：实现线程复用、控制最大并发数；可以系统地管理线程

线程池的优点：

• 下降资源消耗，经过重复利用已建立的线程下降线程频繁建立和销毁的损耗
• 提升响应速度，当任务到达时，任务能够不须要等待线程建立就能当即执行
• 提升线程的可管理性，线程池能够对线程进行统一的分配调度、调优以及监控

$2. 线程池的实现方式

2.1 经过Executors工具类

• Executors.newFixedThreadPool(int nThreads)：固定线程数量线程池

// 源码  
public static ExecutorService newFixedThreadPool(int nThreads) {  
 return new ThreadPoolExecutor(nThreads, nThreads,  
                               0L, TimeUnit.MILLISECONDS,  
                               new LinkedBlockingQueue<Runnable\>());  
}

• Executors.newSingleThreadExecutor()：单线程线程池

// 源码  
public static ExecutorService newSingleThreadExecutor() {  
 return new FinalizableDelegatedExecutorService  
 (new ThreadPoolExecutor(1, 1,  
                         0L, TimeUnit.MILLISECONDS,  
                         new LinkedBlockingQueue<Runnable\>()));  
}

• Executors.newCachedThreadExecutor()：可扩容线程池，理论上支持Integer.MAX_VALUE条线程

// 源码
public static ExecutorService newCachedThreadPool() {  
 return new ThreadPoolExecutor(0, Integer.MAX\_VALUE,  
                               60L, TimeUnit.SECONDS,  
                               new SynchronousQueue<Runnable\>());  
}

实质上，这三种线程池虽然各有特色，但底层实现的都是ThreadPoolExecutor类，也即最正统的线程池，线程池本池☺

• 实际使用

// 使用案例
import java.util.concurrent.Executors;

public class NewFixedThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        // ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // ExecutorService threadPool = Executors.newCachedThreadExecutor();
        
        
        for(int i=0; i<10; i++){
            threadPool.execute(()-> System.out.println(Thread.currentThread().getName() + "\t 办理业务"));
        }
        
        threadPool.shutdown(); // 关闭资源！！
    }
}

2.2 经过ThreadPoolExecutor[线程池本池！用它！用它! 用它！]

WHY？(谁说的不能用Executors？)

• 马云曰：我说的！(阿里编程规范明确表示不建议内部使用Executors工具类实现线程池)
• fixThreadPool和SingleThreadPool设置的任务请求队列为Integer.MAX_VALUE，可能会堆积大量的请求，从而致使OOM
• CachedThreadPool和ScheduledThreadPool容许建立的线程数量为Integer.MAX_VALUE, 可能会建立大量线程，从而致使OOM

// 代码实现
import java.util.concurrent.*;
public class ThreadPoolExecutorDemo {
    public static void main(String[] args) {
        ExecutorService threadPool = new ThreadPoolExecutor(2,
                5,
                2L,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy());

        for(int i=1; i<=10; i++){
            final int temp = i;
            threadPool.execute(()-> System.out.println(Thread.currentThread().getName() + "\t办理业务" + temp));
        }
        threadPool.shutdown();
    }
}

参数解析

• corePoolSize：线程池中的常驻核心线程数
• maximumPoolSize：线程池中可以容纳同时执行的最大线程数，该值必须大于等于1
• keepAliveTime：多余的空闲线程的存货时间，当前池中线程数量大于corePoolSize时，当空闲线程的空闲时间达到keepAliveTime，多余的线程会被销毁直到剩下corePoolSize个
• unit：keepAliveTime的单位
• workQueue：任务队列，被提交但还没有被执行的任务 -- 想象银行的等候区
• threadFactory：表示生成线程池中工做线程的线程工厂，用于建立线程，通常使用默认便可
• handler：拒绝策略，表示当线程池和队列都满了，线程池采起何种策略来拒绝请求执行的Runnable任务

$3. 线程池工做原理

talk is cheap, show me the diagram

线程池通常时间都只会开启核心线程数量的线程，而当任务队列满了以后，线程池会启用非核心线程池区(这里描述只是逻辑分区，实际上线程之间都是同等地位)，建立线程并执行任务；而当任务队列中任务变少，有些线程开始闲置，闲置时间达到设置的keepAliveTime后，线程池会注销回收这些闲置线程，直到线程数量恢复核心线程数

• 一个线程池可以并发处理的最大任务数 = maximumPoolSize + workQueue设置的长度

$4. 拒绝策略(渣男[女]必备)

共有四种拒绝策略，以2.2中的代码为准，即设置核心线程数为二、最大线程数为五、任务队列容量为三、任务数为10；见四种策略分别的运行结果以下

• AbortPolicy：当没法执行任务时，直接抛出RejectedExecutionException中断程序

• CallerRunsPolicy：调用者运行机制，该策略不会抛弃任务，也不会抛出异常，而是将没法执行的任务返还给调用者执行，这里由于是main线程调用的，所以返还给main线程执行任务。以下图，任务9被返还给main线程执行了，这过程的时间内线程池可能已经执行完任务1了，任务队列从而空了一个位置，任务10便直接进入任务队列没有返还给main线程。在保证任务彻底性的状况下，该策略是惟一策略

• DiscardOldestPolicy：抛弃队列中等待最久的任务，而后把当前任务加入到队列中尝试再次提交当前任务

• DiscardPolicy：该策略会丢弃没法处理的任务，不作任何处理也不抛异常，若是容许任务丢失，这是最好的一种策略

REFERENCE

尚硅谷周阳老师JUC课程：https://www.bilibili.com/vide...