线程池源码深度解析

为什么要使用线程池

因为频繁的开启线程或者停止，线程需要重新被cpu从就绪状态到调度，效率非常低，所以使用线程池可以实现复用，从而提高效率。

线程池的作用

1.降低资源消耗：通过池化技术重复利用已创建的线程，降低线程创建和销毁造成的损耗。
2.提高响应速度：任务到达时，无需等待线程创建即可立即执行。
3.提高线程的可管理性：线程是稀缺资源，如果无限制创建，不仅会消耗系统资源，还会因为线程的不合理分布导致资源调度失衡，降低系统的稳定性。使用线程池可以进行统一的分配、调优和监控。
4.提供更多更强大的功能：线程池具备可拓展性，允许开发人员向其中增加更多的功能。比如延时定时线程池ScheduledThreadPoolExecutor，就允许任务延期执行或定期执行。

线程池的类图

线程池的创建方式

Executors.newCachedThreadPool(); 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
Executors.newFixedThreadPool()；可定长度
Executors.newScheduledThreadPool() ； 可定时
Executors.newSingleThreadExecutor(); 单例
底层都是基于ThreadPoolExecutor构造函数封装

非阻塞队列和阻塞队列

阻塞队列：添加元素的时候，当队列满的情况下，可以等待一定的时间，看看有没有空的位置，如果有的话就添加进去，没有的话再返回插入失败
非阻塞队列：添加元素的时候，当队列满的情况下，不等待，直接返回插入失败

阻塞队列

1. ArrayBlockingQueue：
   有界队列，基于数组结构，按照队列FIFO原则对元素排序；
2. LinkedBlockingQueue：
   无界队列，基于链表结构，按照队列FIFO原则对元素排序，Executors.newFixedThreadPool()使用了这个队列； 无界默认是Integer.MAX_VALUE，有界则是 可以自己定义
3. SynchronousQueue：
   同步队列，该队列不存储元素，每个插入操作必须等待另一个线程调用移除操作，否则插入操作会一直被阻塞，Executors.newCachedThreadPool()使用了这个队列；
4. PriorityBlockingQueue：
   优先级队列，具有优先级的无限阻塞队列。

手写模拟线程池

package com.mayikt;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

/**
 * @Description:
 * @Author: ChenYi
 * @Date: 2020/07/26 22:09
 **/

public class MtExector {

    private LinkedBlockingDeque<Runnable> blockingDeque;
    private List<ClassTask> classTaskList;
    private int coreSize;

    private int maxQueue;

    public MtExector(int coreSize, int maxQueue) {
        blockingDeque = new LinkedBlockingDeque<>(maxQueue);
        classTaskList = new ArrayList<>();
        IntStream.rangeClosed(1, coreSize).forEach(i -> {
            ClassTask classTask = new ClassTask();
            classTask.start();
            classTaskList.add(classTask);
        });
    }

    class ClassTask extends Thread {
        @Override
        public void run() {
            while (true) {
                Runnable runnable = blockingDeque.poll();
                if (Objects.nonNull(runnable)) {
                    runnable.run();
                }
            }
        }
    }

    public void execute(Runnable runnable) {
        try {
            blockingDeque.offer(runnable, 1, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        MtExector mtExector = new MtExector(2, 2);
        IntStream.rangeClosed(1, 10).forEach(i -> {
            mtExector.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "," + i);
            });
        });
    }
}

ThreadPoolExecutor核心参数

corePoolSize：核心线程数量，一直正在保持运行的线程
maximumPoolSize：最大线程数，是当队列满的情况下，核心线程数+非核心线程数=最大线程数
keepAliveTime：超时时间，在一定时间内没有线程使用非核心线程数的情况下，则销毁，节约cpu资源
unit：keepAliveTime的时间单位
workQueue：缓存线程队列

1. Thread.setDaemon(boolean on):设置为守护线程或者用户线程。
   通过Thread.setDaemon(false)设置为用户线程,用于为系统中的其它对象和线程提供服务；
2. 通过Thread.setDaemon(true)设置为守护线程,在没有用户线程可服务时会自动离开;如果不设置此属性，默认为用户线程。
   默认是DefaultThreadFactory，里面创建的线程都是用户线程，setDaemon(false),

线程池状态

1. RUNNING ：接收新任务和进程队列任务
2. SHUTDOWN ：不接受新任务，但是会执行进程队列中的任务
3. STOP：不接受新任务也不执行进程队列任务，并且打断正在进行中的任务
4. TIDYING：所有任务终止，待处理任务数量为0，线程转换为TIDYING，将会执行terminated钩子函数
5. TERMINATED：terminated（）执行完成

线程池队列拒绝策略

线程池拒绝线程任务的条件是任务：>最大线程数+队列缓存容量
两种情况会拒绝处理任务：
1.当线程数已经达到maxPoolSize，且队列已满，会拒绝新任务
2.当线程池被调用shutdown()后，会等待线程池里的任务执行完毕，再shutdown。如果在调用shutdown()和线程池真正shutdown之间提交任务，会拒绝新任务。
线程池会调用rejectedExecutionHandler来处理这个任务。如果没有设置，默认是AbortPolicy，会抛出异常。
ThreadPoolExecutor类有几个内部实现类来处理拒绝任务：
1.AbortPolicy 丢弃任务，抛运行时异常rejectedExecutionException

    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }

2.CallerRunsPolicy 执行任务，会调用主线程进行执行

       public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }

3.DiscardPolicy 忽视，什么都不会发生

 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }

4.DiscardOldestPolicy 从队列中踢出最先进入队列（最后一个执行）的任务

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }

5.实现RejectedExecutionHandler接口，可自定义处理器
默认是AbortPolicy拒绝策略

线程池的状态

1.RUNNING：线程池能够接受新任务，以及对新添加的任务进行处理。
2.SHUTDOWN：线程池不可以接受新任务，但是可以对已添加的任务进行处理。
3.STOP：线程池不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
4.TIDYING：当所有的任务已终止，ctl记录的"任务数量"为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行构造函terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。
5.TERMINATED：线程池彻底终止的状态。

核心原理

1. 提交任务的时候比较核心线程数，如果当前任务数量小于核心线程数的情况下，则直接复用线程执行
2. 如果任务量大于核心线程数，则缓存到队列中
3. 如果缓存队列满了，且任务小于最大线程数的情况下，则创建线程执行
4. 如果队列和最大线程数都满的情况下，则走拒绝策略
   参考：蚂蚁课堂