JDk线程池原理解析

1、前言 为什么要用线程池

a、创建线程

• 关于时间，创建线程使用是直接向系统申请资源的，这里调用系统函数进行分配资源的话耗时不好说。
• 关于资源, Java线程的线程栈所占用的内存是在Java堆外的，所以是不受java程序控制的，只受系统资源限制，默认一个线程的线程栈大小是1M（当然这个可以通过设置-Xss属性设置，但是要注意栈溢出问题），但是，如果每个用户请求都新建线程的话，1024个用户光线程就占用了1个G的内存，如果系统比较大的话，一下子系统资源就不够用了，最后程序就崩溃了。
• 对操作系统来说,创建一个线程的代价是十分昂贵的, 需要给它分配内存、列入调度,同时在线程切换的时候还要执行内存换页,CPU 的缓存被 清空,切换回来的时候还要重新从内存中读取信息,破坏了数据的局部性。

b、上下文切换

• 什么是上下文切换？
  举个栗子：医院有固定的科室，以及一定数量的医护人员，如果平时病人不多的话，接诊是很轻松的事，倘若因为某天很多人都生病了，医院肯定忙不过来，这天，赵四去瞧病，刚拍完片子，医生突然接到通知要去处理一个急诊病人，由于人手不够，他只能先记录一下当前赵四都看了什么，然后告诉赵四：刘能腿折了，我先去看他，一会再回来看你
• 上下文切换的实际开销会随着平台的不同而变化，就比如每个医院的看病效率会不同，按照经验来看：在多数通用的处理器中，这个开销相当于5000~10000个始终周期，差不多有几微秒。

c、作用

• 线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使应用程序响应更快。
• 通过适当地调整线程池中的线程数目可以防止出现资源不足的情况。

2、通过一个demo来看线程池到底长什么样？

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ThreadPoolTest {

    // 任务队列 阻塞
    private BlockingQueue<Runnable> taskList = new ArrayBlockingQueue<>(500);
    // 线程集合
    private Set<Thread> workList = new HashSet<>();

    public ThreadPoolTest() {
        this.start();
    }

    // 提交任务
    public void execute(Runnable task) throws InterruptedException  {
        this.taskList.put(task);
    }

    private void start() {
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                while (true) {
                    // 执行任务
                    Runnable task = taskList.poll();
                    task.run();
                }
            });
            this.workList.add(thread);
            thread.start();;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolTest poolTest = new ThreadPoolTest();
        poolTest.execute(new Runnable() {

            @Override
            public void run() {
                System.out.println("Task被执行");
            }

        });
    }

}

3、线程池类继承图

JDK线程池的核心实现类是ThreadPoolExecutor。

• 构造函数
  public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)

1. corePoolSize: 核心线程数
2. maximumPoolSize: 最大线程数
3. keepAliveTime: 当线程数量大于核心线程数时，线程超时时间
4. unit: keepAliveTime的单位
5. workQueue: 任务队列
6. threadFactory: 线程工厂
7. handler: 任务拒绝策略

3、原理解析

• 核心属性
  
  线程池实现类ThreadPoolExecutor，里面主要维护了workQueue(任务队列)和workers(线程集合)。当需要执行的任务会被添加到task任务队列里面，然后workers里面的工作线程才从任务队列获取任务执行。
• execute过程，分为三个步骤
  -
  初始化完成之后任务队列与线程集合都为空。
  1、 当前线程数量小于核心线程数(coolPoolSize)，直接尝试创建新的工作线程（这时创建成功的条件是不超过核心线程数），如果成功则返回，失败则继续。
  2、 如果线程池正在运行，把task添加到任务队列。如果添加成功，需要检查线程池状态和当前线程数量，避免添加成功之后，任务没有得到执行。如果添加失败，则继续。
  3、 尝试创建新的线程（这时创建成功的条件是不超过最大线程数maximumPoolSize），创建成功则返回，否则执行任务拒绝逻辑。
  
• getTask过程，主要分为两个步骤
  
  1、当任务队列为空，且允许核心线程超时或者线程数量大于核心线程数量时。返回一个null，worker线程直接结束。
  2、从任务队列获取task，看是否允许核心线程超时或者线程数量大于核心线程数量，这时通过poll方法加超时(keepAliveTime)逻辑获取任务。否则调用take方法获取任务，会一直阻塞到有新task添加。
  

4、默认实现的优缺点分析

• JDK自带4种的线程池（Executors）

1. 固定线程数的线程池（newFixedThreadPool）
   特点：核心线程数和最大线程数相等，使用的是无界队列。线程数量固定，不会因为任务很多而创建很多的线程。
   缺点：无界队列可能会导致内存溢出。任务少的时候线程资源也不会被释放

2. 缓存的线程池（newCachedThreadPool）
   特点：核心线程数等于0，最大线程数不限制，使用的是无长度同步队列。任务少的时候线程都会被回收，不占用任何资源。不会有任务堆积。
   缺点：可能会频繁的创建和销毁线程，如果任务很多，线程数量会暴涨，导致系统资源不足。

3. 单个线程的线程池（newSingleThreadExecutor）
   特点：核心线程数和最大线程数都等于1，使用的是无界队列。线程数量固定，不会因为任务很多而创建很多的线程。
   缺点：无界队列可能会导致内存溢出。任务多的时候，任务会堆积严重。

4. 固定个数的线程池（newScheduledThreadPool）
   特点：核心线程数和最大线程数相等，使用的是无界队列。线程数量固定，不会因为任务很多而创建很多的线程。能够执行定时任务
   缺点：无界队列可能会导致内存溢出。任务少的时候线程资源也不会被释放

5、其他扩展

• 阻塞队列

1. 接口 BlockingQueue
2. 基于数组的有界队列ArrayBlockingQueue
3. 基于链表的无界队列LinkedBlockingQueue
4. 基于优先堆的延迟队列DelayedWorkQueue

• 定时任务类

5. 接口 ScheduledExecutorService
6. 实现类 ScheduledThreadPoolExecutor
7. 方法 scheduleAtFixedRate和scheduleWithFixedDelay

6、思考

1. 自己在什么项目中用到了线程池或者应该使用却没有用，是否合理。
2. 每个业务里面都单独创建线程或者全局线程池，线程池的大小、任务队列的大小。
3. 线程有哪些状态，状态是怎么流转的？