一、为什么用线程池？它的优势是什么？
线程池坐的主要工作是控制运行的线程的数量，处理过程中将任务放入队列（阻塞队列），然后在线程创建后启动这些任务，如果线程数量超过了最大数量超出的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行；
它的主要特点为：线程复用，控制最大并发数，管理线程；
第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗；
第二：提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行；
第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的管理，调优和监控。
二、线程池如何使用？
1、架构说明：
Java中线程池是通过Executor框架实现的，该框架中用到了Executor、Executors、ExecutorService、ThreadPoolExecutor这几个类 —— 标红的两个非常重要
牢记：线程池的底层就是 ThreadPoolExecutor 这个类；
而 Executors是和Collections，Arrays类似的辅助工具类；List<string> list = Arrays.asList("a","b","c");
2、编码实现：
2.1、作了解（2个）：
-
Executors.newScheduledThreadPool() 带时间调度的，比如池子里面的请求没2秒钟执行一次；
-
java8新出的：Executors.newWorkStealingPool(int）——使用目前机器上可用的处理器作为他的并行级别（用得少）；
2.2、重点（3个）：——又可以理解为第4中获得java多线程的方式
-
Executors.newFixedTHreadPool(int)：一池固定线程数——主要用在：执行长期任务，性能好很多
-
Executors.newSingleThreadExecutor()：一池单线程数——主要用在：一个任务一个任务执行的场景
-
Executors.newCachedThreadPool()：可扩容带缓存的，一池多线程——主要用在：执行很多短期异步的小程序或者负载较轻的服务器
Executors.newFixedTHreadPool(int)：一池固定线程数
| 案例一、银行固定有5个柜台，现在来了10个人办理业务 |
package com.jiguiquan.www.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MyThreadPoolDemo {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(5); //一池固定5个处理线程(5个柜台)
//使用池化技术，永远使用————关闭，关闭比使用更重要：try_catch_finally错不了
try { //模拟10个用户来办理业务，每个用户就是一个来自外部的请求线程
for (int i = 1; i <= 10; i++) {
int tempInt = i;
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+"\t 办理"+tempInt+"的业务");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPool.shutdown();
}
}
}
执行结果：
pool-1-thread-1 办理1的业务 pool-1-thread-3 办理3的业务 pool-1-thread-5 办理5的业务 pool-1-thread-3 办理6的业务 pool-1-thread-2 办理2的业务 pool-1-thread-3 办理9的业务 pool-1-thread-1 办理8的业务 pool-1-thread-5 办理7的业务 pool-1-thread-2 办理10的业务 pool-1-thread-4 办理4的业务
Executors.newSingleThreadExecutor：一池单线程数
| 案例二、将银行柜台数改为1，只有一个柜台 |
ExecutorService threadPool = Executors.newSingleThreadExecutor(); //只有一个柜台
执行结果：
pool-1-thread-1 办理1的业务 pool-1-thread-1 办理2的业务 pool-1-thread-1 办理3的业务 pool-1-thread-1 办理4的业务 pool-1-thread-1 办理5的业务 pool-1-thread-1 办理6的业务 pool-1-thread-1 办理7的业务 pool-1-thread-1 办理8的业务 pool-1-thread-1 办理9的业务 pool-1-thread-1 办理10的业务
Executors.newCachedThreadPool：一池n线程
package com.jiguiquan.www.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class MyThreadPoolDemo {
public static void main(String[] args) {
//ExecutorService threadPool = Executors.newFixedThreadPool(5); //一池固定5个处理线程(5个柜台)
//ExecutorService threadPool = Executors.newSingleThreadExecutor(); //只有一个柜台
ExecutorService threadPool = Executors.newCachedThreadPool();
//使用池化技术，永远使用————关闭，关闭比使用更重要：try_catch_finally错不了
try { //模拟10个用户来办理业务，每个用户就是一个来自外部的请求线程
for (int i = 1; i <= 10; i++) {
int tempInt = i;
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+"\t 办理"+tempInt+"的业务");
});
//暂停一会儿线程
//TimeUnit.MILLISECONDS.sleep(1);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPool.shutdown();
}
}
}
执行结果（注意此时没有让线程暂停）：
pool-1-thread-3 办理3的业务 pool-1-thread-1 办理1的业务 pool-1-thread-4 办理4的业务 pool-1-thread-2 办理2的业务 pool-1-thread-5 办理5的业务 pool-1-thread-7 办理7的业务 pool-1-thread-6 办理6的业务 pool-1-thread-8 办理8的业务 pool-1-thread-10 办理10的业务 pool-1-thread-9 办理9的业务
线程池直接安排了10个线程来办理业务，如果让线程暂停1ms，就会发现，只安排一个柜台就够了，说明是有弹性的，线程数可变的线程池；
pool-1-thread-1 办理1的业务 pool-1-thread-1 办理2的业务 pool-1-thread-1 办理3的业务 pool-1-thread-1 办理4的业务 pool-1-thread-1 办理5的业务 pool-1-thread-1 办理6的业务 pool-1-thread-1 办理7的业务 pool-1-thread-1 办理8的业务 pool-1-thread-1 办理9的业务 pool-1-thread-1 办理10的业务
3、顺着线程池的代码实现，向源码追踪，会发现上面上个的具体实现都是：ThreadExecutor，说明线程池的底层就是这个类；
注意点：
线程池底层都是ThreadPoolExecutor；
线程池底层用来控制池大小的方式，都是依赖于阻塞队列（LinkedBlockingQueue和SynchronousQueue）
三、线程池的几个重要参数介绍（7大参数）
| 问题案例：线程池的几个重要参数，给几个具体的参数，分析线程池会怎么做，最后问其中堵塞队列的作用是什么？ |
可以很清楚的数出来，底层使用的ThreadPoolExecutor共有7大参数：
| CorePoolSize | 线程池中的常驻核心线程数(初始化的值) |
| maximumPoolSize | 线程池能够容纳同时执行的最大线程数，此值必须大于等于1 |
| keepAliveTime |
多余的空闲线程的存活时间： 当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime值时，多余的空闲线程会被销毁直到只剩下corePoolSize个线程为止。 |
| unit | keepAliveTime的时间单位 |
| workQueue |
任务阻塞队列，被提交但尚未被执行的任务待的地方 （类似于银行中的等待区） |
| threadFactory |
表示生成线程池中工作线程的线程工厂，用于创建线程，一般使用默认的即可 （相当于银行网点的logo/工作人员制服/胸卡等，各个网点都一样，标配） |
| handler |
拒绝策略，表示当队列满了并且工作线程也已经大于等于线程池的最大线程数（maximumPoolSize）的时候，如何拒绝新的请求执行的runnable的策略（方案）； （默认有4种拒绝策略） |
四、线程池底层工作原理？
这个底层原理，有助于理解7大参数；
1、在创建了线程池后，等待提交过来的任务请求；
2、当调用execute()方法添加一个请求任务时，线程池会做如下判断：
2.1、如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务；
2.2、如果正在运行的线程数量大于或者等于corePoolSize，那么将这个任务放入队列；
2.3、如果这时候队列满了，且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立即处理这些任务；
2.4、如果队列满了，且正在运行的线程数量大于或者等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行；
3、当一个线程完成任务时，它会自动从队列中取下一个任务来执行；
4、当一个线程无事可做超过一定的时间（keepAliveTime）时，线程会判断：
如果当前运行的线程数大于corePoolSize，那么这个线程就会被停掉（销毁）；
所以线程池的所有任务都处理完成后，它最终会收缩到corePoolSize的大小。
五、线程池的4种拒绝策略？
1、是什么？
等待队列已满+当前线程总数已大于等于最大线程数maximumPoolSize时，这时候我们就需要 拒绝策略机制 合理地处理这个问题；
2、JDK内置的拒绝策略有哪些？
| AbortPolicy(默认) | （火气较大）直接抛出RejectedExecutionException异常阻止系统正常运行； |
| CallerRunsPolicy | “调用者运行”一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者（如main）线程； |
| DiscardOldestPolicy | 抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务； |
| DiscardPolicy | 直接丢弃任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种方案； |
以上内置的拒绝策略均实现了 “RejectedExecutionHandler”接口；
六、实际工作中使用哪一种线程池
这里我们引用一下“阿里巴巴JAVA开发手册”中的内容：
| 经典问题，大坑：在工作中，固定数、单一数和可变数的线程池创建方式，你们是选用的哪一个？ |
这个问题，你回答任何一个都是错，必须回答：
一个都不用，它们都存在问题，我们生产中使用线程池时候，都是通过ThreadPoolExecutor自定义线程池；
七、通过ThreadPoolExecutor自定义线程池
1、代码实现：默认拒绝策略AbortPolicy脾气暴躁型
package com.jiguiquan.www.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
** 通过ThreadPoolExecutor自定义线程池
* @author jiguiquan
*
*/
public class MyOwnThreadPool {
public static void main(String[] args) {
//自定义线程池
ExecutorService myThreadPool = new ThreadPoolExecutor(
2, //corePoolSize
5, //maximumPoolSize
1, //keepAliveTime
TimeUnit.SECONDS, //unit
new LinkedBlockingQueue<Runnable>(3), //workQueue
Executors.defaultThreadFactory(), //threadFactory
new ThreadPoolExecutor.AbortPolicy() //handler
);
//模拟8个用户来办理业务，正常运行；如果9个人来办理，那么会报异常（AbortPolicy的拒绝策略）
try {
for (int i = 1; i <= 8; i++) {
int tempInt = i;
myThreadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+"\t 办理第 "+tempInt+" 个人的业务");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
myThreadPool.shutdown();
}
}
}
执行结果：
但是如果将办理业务的人数上升到9人时候，线程池会直接抛出异常；因为现在使用的是默认抛异常的拒绝策略（AbortPolicy）；
2、现在将拒绝策略修改为：CallerRunsPolicy回退调用者处理
即使将办理人数增加到10人，结果如下：
main 办理第 9 个人的业务 pool-1-thread-1 办理第 1 个人的业务 pool-1-thread-4 办理第 7 个人的业务 pool-1-thread-1 办理第 3 个人的业务 pool-1-thread-4 办理第 4 个人的业务 pool-1-thread-3 办理第 6 个人的业务 pool-1-thread-5 办理第 8 个人的业务 pool-1-thread-2 办理第 2 个人的业务 pool-1-thread-1 办理第 5 个人的业务 main 办理第 10 个人的业务
3、将拒绝策略更改为：DiscardOldestPolicy抛弃等待时间最久的那些（抛弃3、4）
pool-1-thread-3 办理第 6 个人的业务 pool-1-thread-4 办理第 7 个人的业务 pool-1-thread-4 办理第 5 个人的业务 pool-1-thread-4 办理第 9 个人的业务 pool-1-thread-4 办理第 10 个人的业务 pool-1-thread-2 办理第 2 个人的业务 pool-1-thread-1 办理第 1 个人的业务 pool-1-thread-5 办理第 8 个人的业务
4、将拒绝策略更改为：DiscardPolicy抛弃最后到的哪些（抛弃9、10）
pool-1-thread-1 办理第 1 个人的业务 pool-1-thread-4 办理第 7 个人的业务 pool-1-thread-4 办理第 3 个人的业务 pool-1-thread-4 办理第 4 个人的业务 pool-1-thread-2 办理第 2 个人的业务 pool-1-thread-3 办理第 6 个人的业务 pool-1-thread-4 办理第 5 个人的业务 pool-1-thread-5 办理第 8 个人的业务
八、工作中如何配置自定义线程池的合理线程数
这个问题要取决于你的业务的性质：
使用
System.out.println("CPU的核数为："+Runtime.getRuntime().availableProcessors());
可查询设备的CPU核数，本人电脑为4核；
CPU的核数为：4
1、CPU密集型业务（大量的运算）
CPU核数+1个线程数 = 5；
2、IO密集型业务——2种设置方式
2.1、由于 IO 密集型任务线程并不是一直在执行任务，可以多分配一点线程数，如 CPU * 2 = 8；
2.2、也可以使用公式：CPU 核数 / (1 – 阻塞系数)；其中阻塞系数在 0.8 ～ 0.9 之间。 （20~40之间）
九、死锁编码及定位分析
1、是什么？
死锁是指2个或2个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力干涉，那它们将无法推进下去；
如果系统资源充足，线程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因为争夺有限的资源而陷入死锁；
2、代码（写一个死锁）
代码演示：
package com.jiguiquan.www;
import java.util.concurrent.TimeUnit;
/**
** 死锁的代码演示
* 持有自己的锁，还妄图得到别人的锁
* @author jiguiquan
*
*/
public class DeadLockDemo {
public static void main(String[] args) {
String lockA = "lockA";
String lockB = "lockB";
//创建两个线程
new Thread(new HoldLockThread(lockA, lockB),"ThreadAAA").start();
new Thread(new HoldLockThread(lockB, lockA),"ThreadBBB").start();
}
}
class HoldLockThread implements Runnable {
//至少需要两把锁
private String lockA;
private String lockB;
public HoldLockThread(String lockA, String lockB) {
this.lockA = lockA;
this.lockB = lockB;
}
@Override
public void run() {
synchronized (lockA) {
System.out.println(Thread.currentThread().getName()+"\t 自己持有："+lockA+"还尝试获得"+lockB);
try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}
synchronized (lockB) {
System.out.println(Thread.currentThread().getName()+"\t 自己持有："+lockB+"还尝试获得"+lockA);
}
}
}
}
执行结果：
可以看到，程序已经陷入死锁，无法正常结束；
3、如果解决？
3.1、首先，如何查看所有的java进程？
在linux中，我们使用 ps -ef|grep java 查看； ls -l（小写的L）
在windows下，也有类似于linux中 ps 的查看进程的命令，但是目前我们只需要查看的是 java
使用 jps 即 jps = java ps, jps -l（小写的L）
3.2、使用jps -l 命令查定位进程号：
D:\学习\多线程\ThreadPool\src\com\jiguiquan\www>jps -l 13720 sun.tools.jps.Jps 14120 11292 com.jiguiquan.www.DeadLockDemo
3.3、使用jstack 11292 找到死锁查看：
Found one Java-level deadlock: ============================= "ThreadBBB": waiting to lock monitor 0x0000000002c88168 (object 0x000000076b5d2560, a java.lang.String), which is held by "ThreadAAA" "ThreadAAA": waiting to lock monitor 0x0000000002c8ab58 (object 0x000000076b5d2598, a java.lang.String), which is held by "ThreadBBB" Java stack information for the threads listed above: =================================================== "ThreadBBB": at com.jiguiquan.www.HoldLockThread.run(DeadLockDemo.java:40) - waiting to lock <0x000000076b5d2560> (a java.lang.String) ----等待d2560 - locked <0x000000076b5d2598> (a java.lang.String) ----锁着d2598 at java.lang.Thread.run(Thread.java:748) "ThreadAAA": at com.jiguiquan.www.HoldLockThread.run(DeadLockDemo.java:40) - waiting to lock <0x000000076b5d2598> (a java.lang.String) ----等待d2598 - locked <0x000000076b5d2560> (a java.lang.String) ----锁着d2560 at java.lang.Thread.run(Thread.java:748) Found 1 deadlock.
可以清楚地看到“Found 1 deadlock”找到一处死锁；
两个线程的等待和持有的锁，明显地矛盾，形成死锁；
