线程池

一、为什么使用线程池：

当我们有大量的任务时，每个任务都需要开一个线程单独处理；
性能：出于性能考虑，不能直接使用new Thread创建线程：

1.需要控制并发量，不应该无限制的开启线程
2.需要充分利用已有线程，避免资源浪费

二、runnable和thread的解耦关系

任务与线程分离，是一种解耦，更方便的重复利用线程执行不同的任务，这是线程池最基本的原理；
开子线程的方式：

1.继承thread类并重写run方法
class MyThread extends Thread{
@Override
public void run() {}
}
MyThread thread = new MyThread();
thread.start();

2.实现runnable接口并重写run方法
class MyRunnable implements Runnable{
@Override
public void run() {}
}
Thread thread=new Thread(runnable);
thread.start();

三、阻塞队列

当我们想要去控制同时进行的线程数量也就是并发量时，势必就需要把还没来得及进行的任务存储在容器中等待，这就需要引入阻塞队列。

为什么使用阻塞队列而不是其他容器：

1.需要线程安全，因为涉及了容器的并发修改，在主线程存任务，在工作线程取任务；
2.需要在线程中从任务队列中取任务时，在取不到时应该让线程阻塞挂起等待，有任务时在唤醒线程继续；

什么是阻塞队列：

1.首先它是一个容器或者说是一个集合，它的数据结构是队列，特点是先进先出（FIFO：First In First Out）
2.其次它以下两种情况，它会阻塞线程：
线程 1 往阻塞队列中添加元素，线程 2 从阻塞队列中移除元素
当阻塞队列是空时，从队列中获取元素的操作将会阻塞线程1。
当阻塞队列是满时，从队列中添加元素的操作将会阻塞线程2。

线程池中常用的阻塞队列：
LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。
SynchronousQueue：一个不存储元素的阻塞队列。SynchronousQueue是一个不存储元素的阻塞队列。每一个put操作必须等待一个take操作，否则不能继续添加元素。SynchronousQueue可以看成是一个传球手，负责把生产者线程处理的数据直接传递给消费者线程。队列本身并不存储任何元素，非常适合于传递性场景,比如在一个线程中使用的数据，传递给另外一个线程使用，

四、线程池的使用方式

（1）使用Executors工具类自带的配置好参数的四种线程池

1、Fix 固定数量的线程池

使用：Executors.newFixedThreadPool();
源码：

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

corePoolSize = maximunPoolSize = 固定数量
LinkedBlockingQueue：无界阻塞队列
场景分析：线程池中最多只存在固定数量的线程在工作，后续新来的任务则在队列中等待；

2、Single 单独一个的线程池

使用：Executors.newSingleThreadExecutor();
源码：

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

corePoolSize = maximunPoolSize = 1
LinkedBlockingQueue：无界阻塞队列
场景分析：线程池中最多只有一个线程在工作，后续新来的任务则在队列中等待；

3、Cache 高速缓存，高速响应的线程池

使用：Executors.newCachedThreadPool();
源码：

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
}

corePoolSize：0
maximunPoolSize：无限大
SynchronousQueue：无容量的阻塞队列
场景分析：没有核心线程，也就是说到来的任务，直接入队列，然而队列是无容量的，也就是说新来的任务直接开辟新的线程执行；

4、Schedule 周期 定时线程池

使用：

ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        executor.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                //定时任务
            }
        }, 延迟：0, 每隔：1000, 单位：TimeUnit.MILLISECONDS);

场景分析：定时任务

（2）使用ThreadPoolExecutor自己构建线程池参数

image.png

executorService.execute(new Runnable() {
                @Override
                public void run() {
                   //这里处理业务逻辑
                }
            });

五、线程池的工作原理简述：

1.如果当前正在运行的线程总数小于核心线程数量corePoolSize，
则添加一个新的线程thread，并执行当前任务runnable
2.如果当前运行的线程总数大于等于corePoolSize
则把当前任务放入工作队列中等待
3.如果工作队列满了，并且最大线程数maximumPoolSize未满
则创建一个新的线程执行任务
4.最大线程数maximumPoolSize已满
则采用拒绝执行任务

线程池中正在工作的线程在什么时候取出任务呢？

BlockingQueue<Runnable> workQueue；//任务队列
//线程执行
runTask(){
   while (runnable!= null || (runnable= workQueue.take()) != null) {
    runnable.run();
    runnable= null;
  }
}

1.当新的线程第一次执行时，这时runnable!=null条件满足，然后执行当前这个任务runnable.run()；
2.当这个任务执行结束时，runnable会被赋值null，然后进入while 下一次循环，调用workQueue.take()从任务队列中取任务继续执行，没有任务则阻塞挂起当前线程进行等待；

Glide 使用了两个线程池

ExecutorService diskCacheService; 用于从本地磁盘缓存文件中加载图片数据流
corePoolSize=maximumPoolSize=1 阻塞队列使用优先级无界阻塞队列 PriorityBlockingQueue
ExecutorService sourceService; 用于获取服务器图片数据流
corePoolSize=maximumPoolSize=Runtime.getRuntime().availableProcessors()
阻塞队列使用优先级无界阻塞队列PriorityBlockingQueue

必须掌握：

四种线程池极其配置参数
线程池的基本运作流程