图文详解 Java线程池

1、线程池的优势

（1）降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗； （2）提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行； （3）方便线程并发数的管控。因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM，并且会造成cpu过度切换（cpu切换线程是有时间成本的（需要保持当前执行线程的现场，并恢复要执行线程的现场））。 （4）提供更强大的功能，延时定时线程池。

2、构造线程池的主要参数

// Java线程池的完整构造函数
public ThreadPoolExecutor(
    // 线程池长期维持的线程数，即使线程处于Idle状态，也不会回收。
    int corePoolSize, 
    // 线程数的上限
    int maximumPoolSize, 
    // 超过corePoolSize的线程的idle时长，
    // 超过这个时间，多余的线程会被回收。
    long keepAliveTime, TimeUnit unit,
    // 任务的排队队列
    BlockingQueue<Runnable> workQueue, 
    // 新线程的产生方式
    ThreadFactory threadFactory, 
    // 拒绝策略
    RejectedExecutionHandler handler)

构造一个线程池确实需要这么多参数。

    /**
     * ThreadPoolExecutor(
    int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory,
    RejectedExecutionHandler handler)
     */
    val tp = ThreadPoolExecutor(
        5,
        10,
        10,
        TimeUnit.SECONDS,
        //workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，
        // 会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：
        // ArrayBlockingQueue;
        //LinkedBlockingQueue;
        //SynchronousQueue;
        ArrayBlockingQueue(10),
        Executors.defaultThreadFactory(),
        // handler：表示当拒绝处理任务时的策略，有以下四种取值：
        //ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
        //ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
        //ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
        //ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务
        ThreadPoolExecutor.AbortPolicy()
    )

这些参数中，比较容易引起问题的有corePoolSize, maximumPoolSize, workQueue以及handler：

corePoolSize和maximumPoolSize设置不当会影响效率，甚至耗尽线程； workQueue设置不当容易导致OOM； handler设置不当会导致提交任务时抛出异常。

参数说明：

• corePoolSize（线程池基本大小）：当向线程池提交一个任务时，若线程池已创建的线程数小于corePoolSize，即便此时存在空闲线程，也会通过创建一个新线程来执行该任务，直到已创建的线程数大于或等于corePoolSize时，（除了利用提交新任务来创建和启动线程（按需构造），也可以通过 prestartCoreThread() 或 prestartAllCoreThreads() 方法来提前启动线程池中的基本线程。）
• maximumPoolSize（线程池最大大小）：线程池所允许的最大线程个数。当队列满了，且已创建的线程数小于maximumPoolSize，则线程池会创建新的线程来执行任务。另外，对于无界队列，可忽略该参数。
• keepAliveTime（线程存活保持时间）当线程池中线程数大于核心线程数时，线程的空闲时间如果超过线程存活时间，那么这个线程就会被销毁，直到线程池中的线程数小于等于核心线程数。
• workQueue（任务队列）：用于传输和保存等待执行任务的阻塞队列。
• threadFactory（线程工厂）：用于创建新线程。threadFactory创建的线程也是采用new Thread()方式，threadFactory创建的线程名都具有统一的风格：pool-m-thread-n（m为线程池的编号，n为线程池内的线程编号）。
• handler（线程饱和策略）：当线程池和队列都满了，再加入线程会执行此策略。

3、线程池流程

1、判断线程池中当前线程数是否大于核心线程数，如果小于，在创建一个新的线程来执行任务; 如果大于转2； 2、判断任务队列是否已满，没满则将新提交的任务添加在工作队列，已满则转3。 3、判断线程池中当前线程数是否大于最大线程数，如果小于，则创建一个新的线程来执行任务，如果大于，则执行饱和策略。

线程池的工作顺序: corePoolSize -> 任务队列 -> maximumPoolSize -> 拒绝策略

If fewer than corePoolSize threads are running, the Executor always prefers adding a new thread rather than queuing. If corePoolSize or more threads are running, the Executor always prefers queuing a request rather than adding a new thread. If a request cannot be queued, a new thread is created unless this would exceed maximumPoolSize, in which case, the task will be rejected.

4、线程池为什么需要使用（阻塞）队列？

回到了非线程池缺点中的第3点： 1、因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM，并且会造成cpu过度切换。

另外回到了非线程池缺点中的第1点： 2、创建线程池的消耗较高。 或者下面这个网上并不高明的回答： 2、线程池创建线程需要获取mainlock这个全局锁，影响并发效率，阻塞队列可以很好的缓冲。

5、线程池为什么要使用阻塞队列而不使用非阻塞队列？

阻塞队列可以保证任务队列中没有任务时阻塞获取任务的线程，使得线程进入wait状态，释放cpu资源。 当队列中有任务时才唤醒对应线程从队列中取出消息进行执行。 使得在线程不至于一直占用cpu资源。

（线程执行完任务后通过循环再次从任务队列中取出任务进行执行，代码片段如下 while (task != null || (task = getTask()) != null) {}）。

不用阻塞队列也是可以的，不过实现起来比较麻烦而已，有好用的为啥不用呢？

6、如何配置线程池

CPU密集型任务 尽量使用较小的线程池，一般为CPU核心数+1。 因为CPU密集型任务使得CPU使用率很高，若开过多的线程数，会造成CPU过度切换。

IO密集型任务 可以使用稍大的线程池，一般为2*CPU核心数。 IO密集型任务CPU使用率并不高，因此可以让CPU在等待IO的时候有其他线程去处理别的任务，充分利用CPU时间。

混合型任务 可以将任务分成IO密集型和CPU密集型任务，然后分别用不同的线程池去处理。 只要分完之后两个任务的执行时间相差不大，那么就会比串行执行来的高效。 因为如果划分之后两个任务执行时间有数据级的差距，那么拆分没有意义。 因为先执行完的任务就要等后执行完的任务，最终的时间仍然取决于后执行完的任务，而且还要加上任务拆分与合并的开销，得不偿失。

7、java中提供的线程池

Executors类提供了4种不同的线程池：newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool, newSingleThreadExecutor

1、newCachedThreadPool：用来创建一个可以无限扩大的线程池，适用于负载较轻的场景，执行短期异步任务。（可以使得任务快速得到执行，因为任务时间执行短，可以很快结束，也不会造成cpu过度切换）

2、newFixedThreadPool：创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于负载较重的场景，对当前线程数量进行限制。（保证线程数可控，不会造成线程过多，导致系统负载更为严重）

3、newSingleThreadExecutor：创建一个单线程的线程池，适用于需要保证顺序执行各个任务。

4、newScheduledThreadPool：适用于执行延时或者周期性任务。

8、execute()和submit()方法

1、execute()，执行一个任务，没有返回值。 2、submit()，提交一个线程任务，有返回值。 submit(Callable<T> task)能获取到它的返回值，通过future.get()获取（阻塞直到任务执行完）。一般使用FutureTask+Callable配合使用（IntentService中有体现）。

submit(Runnable task, T result)能通过传入的载体result间接获得线程的返回值。 submit(Runnable task)则是没有返回值的，就算获取它的返回值也是null。

Future.get方法会使取结果的线程进入阻塞状态，知道线程执行完成之后，唤醒取结果的线程，然后返回结果。

https://www.cnblogs.com/dolphin0520/p/3949310.html

9、阻塞队列

10、线程池的状态

首先认识两个贯穿线程池代码的参数：

runState：线程池运行状态 workerCount：工作线程的数量

在 ThreadPoolExecutor 中定义了一个 volatile 变量，另外定义了几个 static final 变量表示线程池的各个状态：

volatile int runState;
static final int RUNNING    = 0;
static final int SHUTDOWN   = 1;
static final int STOP       = 2;
static final int TERMINATED = 3;

runState 表示当前线程池的状态，它是一个 volatile 变量用来保证线程之间的可见性；

下面的几个 static final 变量表示 runState 可能的几个取值。

当创建线程池后，初始时，线程池处于 RUNNING 状态；

如果调用了 shutdown() 方法，则线程池处于 SHUTDOWN 状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕；

如果调用了shutdownNow()方法，则线程池处于STOP状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务；

当线程池处于 SHUTDOWN 或 STOP 状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态。

参考文章

1.https://mp.weixin.qq.com/s?src=11&timestamp=1616077526&ver=2954&signature=Ug1Ez6aIqI0NOaB6k6BdOpjacTGQT6GFZdVEGDqJajkgY6jyTB3hkpmCUyA77V7ftsGIcZVGF81i5j13cMsEsC--mqjd58LEqZOq0sXFxo4VD2qTtTl5ICFErvghSq&new=1 2.https://mp.weixin.qq.com/s?src=11&timestamp=1616077526&ver=2954&signature=Ug1Ez6aIqI0NOaB6k6BdOpjacTGQT6GFZdVEGDqJajkgY6jyTB3hkpmCUyA77V7ftsGIcZVGF81i5j13cMsEsC--mqjd58LEqZOq0sXFxo4VD2qTtTl5ICFErvghSq&new=1