线程池：

为什么用线程池？

主要工作

线程池主要工作是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。

特点

线程复用，控制最大并发数，管理线程

优势

降低资源消耗，通过重复利用已创建的线程，降低线程创建和销毁造成的消耗。
提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行。
提高线程的可管理性。线程时稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性。使用线程池进行统一的分配，调优和控制。

线程池的常用三种方式：（第四种使用java多线程的方式）

线程池的底层执行类就是 ThreadPoolExecutor
1. Executors.newFixedThreadPool(int)
2. Executors.newSingleThreadExecutor(int)
3. Executors.newCachedThreadPool(int)
  以上是api工程师调用的，不推荐使用。

线程池创建的七大参数

1(默认是五大参数，学的更多更细致，七大参数)

corePoolSize 线程池中的核心线程数。
- 创建了线程后，当有请求任务来了之后，就会安排池中的线程去执行请求任务，近似理解为今日当值线程。
- 当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列中。
maxPoolSize, 线程池能够容纳同时执行的最大线程数，此值必须大于等于1。
keepAliveTime：多余空闲线程的存活时间。当线程池的数量超过corePoolSize, 并且空闲时间达到keepAliveTime值时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止。
- 默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize。
unit, keepAliveTime的单位。
workQueue，阻塞队列
（类似银行的候客区）
threadFactory，线程池默认的配置
- 例如银行网点的全部东西（logo,工作制服，胸卡）
handler，线程池的拒绝策略
- 例如maxPoolSizez最大线程数已经满了，都在处理任务，阻塞队列已满，线程池就开始执行拒绝策略（银行门口挂牌，请到其他网点处理）

参数设置

 11、默认值
 2    * corePoolSize=1
 3    * queueCapacity=Integer.MAX_VALUE
 4    * maxPoolSize=Integer.MAX_VALUE
 5    * keepAliveTime=60s
 6    * allowCoreThreadTimeout=false
 7    * rejectedExecutionHandler=AbortPolicy()
 8
 92、如何来设置
10    * 需要根据几个值来决定
11        - tasks ：每秒的任务数，假设为500~1000
12        - taskcost：每个任务花费时间，假设为0.1s
13        - responsetime：系统允许容忍的最大响应时间，假设为1s
14    * 做几个计算
15        - corePoolSize = 每秒需要多少个线程处理？ 
16            * threadcount = tasks/(1/taskcost) =tasks*taskcout =  (500~1000)*0.1 = 50~100 个线程。corePoolSize设置应该大于50
17            * 根据8020原则，如果80%的每秒任务数小于800，那么corePoolSize设置为80即可
18        - queueCapacity = (coreSizePool/taskcost)*responsetime
19            * 计算可得 queueCapacity = 80/0.1*1 = 800。意思是队列里的线程可以等待1s，超过了的需要新开线程来执行
20            * 切记不能设置为Integer.MAX_VALUE，这样队列会很大，线程数只会保持在corePoolSize大小，当任务陡增时，不能新开线程来执行，响应时间会随之陡增。
21        - maxPoolSize = (max(tasks)- queueCapacity)/(1/taskcost)
22            * 计算可得 maxPoolSize = (1000-80)/10 = 92
23            * （最大任务数-队列容量）/每个线程每秒处理能力 = 最大线程数
24        - rejectedExecutionHandler：根据具体情况来决定，任务不重要可丢弃，任务重要则要利用一些缓冲机制来处理
25        - keepAliveTime和allowCoreThreadTimeout采用默认通常能满足
26
273、 以上都是理想值，实际情况下要根据机器性能来决定。如果在未达到最大线程数的情况机器cpu load已经满了，则需通过升级硬件（呵呵）和优化代码，降低taskcost来处理。

I/O
waiting time (WT)
service time (ST) for a typical request.
If we call this ratio WT/ST,
for an N-processor system,
you'll want to have approximately N*(1+WT/ST) threads to keep the processors fully utilized.

核心代码：

 1 public ThreadPoolExecutor(int corePoolSize,
 2                          int maximumPoolSize,
 3                          long keepAliveTime,
 4                          TimeUnit unit,
 5                          BlockingQueue<Runnable> workQueue) {
 6    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
 7         Executors.defaultThreadFactory(), defaultHandler);
 8}
 9
10public ThreadPoolExecutor(int corePoolSize,
11                          int maximumPoolSize,
12                          long keepAliveTime,
13                          TimeUnit unit,
14                          BlockingQueue<Runnable> workQueue,
15                          ThreadFactory threadFactory,
16                          RejectedExecutionHandler handler) {
17    if (corePoolSize < 0 ||
18        maximumPoolSize <= 0 ||
19        maximumPoolSize < corePoolSize ||
20        keepAliveTime < 0)
21        throw new IllegalArgumentException();
22    if (workQueue == null || threadFactory == null || handler == null)
23        throw new NullPointerException();
24    this.acc = System.getSecurityManager() == null ?
25            null :
26            AccessController.getContext();
27    this.corePoolSize = corePoolSize;
28    this.maximumPoolSize = maximumPoolSize;
29    this.workQueue = workQueue;
30    this.keepAliveTime = unit.toNanos(keepAliveTime);
31    this.threadFactory = threadFactory;
32    this.handler = handler;
33}

线程池的底层工作原理：

原理图
线程池执行原理图
执行步骤：

进来一个任务，判断corePoolSize个线程是否已经被占满。若有空闲，执行任务。
若corePoolSize个线程已被占用，当前任务判断阻塞队列是否已满，有空闲，进入等待队列。
若阻塞队列已满，则申请新的线程数，若当线程数未达到最大上线，申请成功，执行任务。
若当前工作线程已达到maximumPoolSize，执行拒绝策略。

处理流程图

工作原理（重要）

在创建了线程池后，等待提交过来的任务请求。
当调用execute()方法添加一个请求任务时，线程池会做一下判断：
- 若正在运行的数量< corePoolSize，马上创建线程运行此任务。
- 若正在运行的线程数量 >= corePoolSize, 则将此任务放入队列。
- 若此时队列已满，且正在运行的线程数 < maximumPoolSize，则创建非核心线程运行此任务。
- 若队列已满，且正在运行的线程数 >= maximumPoolSize, 线程池启动饱和拒绝策略执行。
当一个线程完成任务时，它会从队列中取下一个任务来执行。
当一个线程无事可做超过一定时间（keepAliveTime）, 线程池会判断：
- 若当前运行线程数>corePoolSize, 则停掉这个线程，线程池所有任务完成后，最终收缩到corePoolSize的大小。

线程池的拒绝策略

等待队列已满，再也塞不下新任务，且线程池中的max线程达到了，无法继续为新任务服务，这时候执行拒绝策略。

AbortPolicy(默认)：直接跑出RejectedExecutionException 异常阻止系统正常运行。

CallerRunsPolicy: "调用者运行"一种调节机制，该策略既不会抛弃任务，也不会抛异常，而是将某些任务回退到调用者，从而降低新任务的流量。
DiscardOldestPolicy: 抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试。
DiscardPolicy：直接丢弃任务，不做任何处理也不抛异常，如果允许任务丢失，这是最好的策略。

线程池使用原理

线程池：

为什么用线程池？

主要工作

特点

优势

线程池的常用三种方式：（第四种使用java多线程的方式）

线程池创建的七大参数

参数设置

核心代码：

线程池的底层工作原理：

线程池的拒绝策略