1、为什么要使用线程池
线程池能有效管控线程，统一分配任务，优化资源使用。
2、线程池的参数
创建线程池，在构造一个新的线程池时，必须满足下面的条件：
corePoolSize（线程池基本大小）必须大于或等于0；
maximumPoolSize（线程池最大大小）必须大于或等于1；
maximumPoolSize必须大于或等于corePoolSize；
keepAliveTime（线程存活保持时间）必须大于或等于0；
workQueue（任务队列）不能为空；
threadFactory（线程工厂）不能为空，默认为DefaultThreadFactory类（可以通过线程工厂对不同线程池的线程名称进行设置，以区分产生bug的线程是哪个池的）
handler（线程饱和策略）不能为空，默认策略为ThreadPoolExecutor.AbortPolicy。
线程池参数围绕两个核心，线程和任务。
线程相关的参数：核心线程数，最大线程数，线程存活保持时间，线程饱和策略，线程工厂。
任务相关的参数：任务队列。
3、线程池执行过程
1、创建核心线程处理任务，失败则继续
2、将任务添加到任务队列
3、创建非核心线程处理任务
4、线程饱和策略
4、核心参数分析
4.1 任务队列
4.1.1 直接提交队列SynchronousQueue
设置为SynchronousQueue队列，SynchronousQueue是一个特殊的BlockingQueue，它没有容量，每执行一个插入操作就会阻塞。一般使用SynchronousQueue都会要求为无界(maximumPoolSize=Integer.MAX_VALUE)。
public class PoolTask implements Runnable{
public int i;
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 正在执行 " + i + " 号任务");
}
public PoolTask(int i) {
this.i = i;
}
} public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new SynchronousQueue<>());
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
threadPoolExecutor.execute(poolTask);
}
threadPoolExecutor.shutdown();
}执行结果：
4.1.2 有界的任务队列ArrayBlockingQueue
一般使用ArrayBlockingQueue来实现。使用ArrayBlockingQueue有界任务队列，若有新的任务需要执行时，线程池会创建新的线程，直到创建的线程数量达到corePoolSize时，会将新的任务加入到等待队列中。这里等待队列的任务数量设置为2，若等待队列已满，即超过ArrayBlockingQueue初始化的容量，则继续创建线程，直到线程数量达到maximumPoolSize设置的最大线程数量，若大于maximumPoolSize，则执行拒绝策略。
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2));
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
threadPoolExecutor.execute(poolTask);
}
threadPoolExecutor.shutdown();
}执行结果：
4.1.3 无界的任务队列LinkedBlockingQueue
一般使用LinkedBlockingQueue来实现。使用无界的任务队列，线程池的任务队列可以无限制添加新任务，而线程池创建的最大线程数就是corePoolSize设置的数量，这种情况下maximumPoolSize设置的值是不会生效的，就算等待队列中有许多未执行的任务，线程池的数量达到了corePoolSize的值后也不会增加新的线程。
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
threadPoolExecutor.execute(poolTask);
}
threadPoolExecutor.shutdown();
}运行结果：
4.1.4 优先任务队列PriorityBlockingQueue
一般使用PriorityBlockingQueue来实现。任务需要实现comparable接口，根据任务的优先级执行任务。
public class PoolTask implements Runnable, Comparable<PoolTask>{
public int i;
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 正在执行 " + i + " 号任务");
}
public PoolTask(int i) {
this.i = i;
}
@Override
public int compareTo(PoolTask o) {
//升序排序
return o.getI() - this.getI();
}
} public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new PriorityBlockingQueue<>());
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
threadPoolExecutor.execute(poolTask);
}
threadPoolExecutor.shutdown();
}运行结果：
4.2 线程饱和策略
4.2.1 ThreadPoolExecutor.AbortPolicy
线程池默认的阻塞策略。不执行此任务，而且抛出一个运行时异常（未检查的异常RejectedExecutionException）。
切记：ThreadPoolExecutor.execute需要try catch，否则程序会直接退出。
ThreadPoolExecutor.DiscardPolicy
不执行此任务，而且不抛异常。（是个空方法）
public class PoolTask implements Runnable, Comparable<PoolTask>{
public int i;
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 正在执行 " + i + " 号任务");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public PoolTask(int i) {
this.i = i;
}
@Override
public int compareTo(PoolTask o) {
//升序排序
return o.getI() - this.getI();
}
}public class PoolTest {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
try {
threadPoolExecutor.execute(poolTask);
} catch (Exception e) {
e.printStackTrace();
}
}
threadPoolExecutor.shutdown();
}
}运行结果：
4.2.2 ThreadPoolExecutor.DiscardOldestPolicy
从队列里删除最老的任务（头部的一个任务），并再次execute 此task。
public class PoolTest {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardOldestPolicy());
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
try {
threadPoolExecutor.execute(poolTask);
} catch (Exception e) {
e.printStackTrace();
}
}
threadPoolExecutor.shutdown();
}
}运行结果：
4.2.3 ThreadPoolExecutor.CallerRunsPolicy
让调用execute方法的线程执行此command，会阻塞入口。
这是个调节机制，既不抛弃任务也不抛出异常，而是将某些任务回退到调用者，让调用者所在的线程去执行。
public class PoolTest {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
try {
threadPoolExecutor.execute(poolTask);
} catch (Exception e) {
e.printStackTrace();
}
}
threadPoolExecutor.shutdown();
}
}
运行结果：
4.2.4 用户自定义拒绝策略（最常用）
实现RejectedExecutionHandler，并自己定义策略模式
package com.example.dyc.mythreadpool;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
public class MyThreadPolicy implements RejectedExecutionHandler {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
if (r instanceof PoolTask){
PoolTask poolTask = (PoolTask) r;
if (poolTask.getI() != 6){
return;
}
System.out.println("获取到六号任务，试图放入队列");
BlockingQueue<Runnable> queue = executor.getQueue();
while (true) {
if (queue.remainingCapacity() > 0) {
queue.add(poolTask);
System.out.println("放入队列成功");
break;
} else {
try {
System.out.println("放入队列失败，继续试图放入");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
public class PoolTest {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new MyThreadPolicy());
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
try {
threadPoolExecutor.execute(poolTask);
} catch (Exception e) {
e.printStackTrace();
}
}
threadPoolExecutor.shutdown();
}
}
运行结果：
5 常用线程池类型
java通过Executors提供四种线程池，分别为：
5.1 newCachedThreadPool
newCachedThreadPool创建一个可缓存的无界线程池，如果线程池长度超过处理需要，可灵活回收空线程，若无可回收，则新建线程。当线程池中的线程空闲时间超过60s，则会自动回收该线程，当任务超过线程池的线程数则创建新的线程，线程池的大小上限为Integer.MAX_VALUE,可看作无限大。
5.2 newFixedThreadPool
newFixedThreadPool创建一个指定大小的线程池，可控制线程的最大并发数，超出的线程会在LinkedBlockingQueue阻塞队列中等待。
5.3 newScheduledThreadPool
newScheduledThreadPool线程池支持定时以及周期性执行任务，创建一个corePoolSize为传入参数，最大线程数为整形的最大数的线程池
5.4 newSingleThreadExecutor
newSingleThreadExecutor创建一个单线程化的线程池，它只有一个线程，用仅有的一个线程来执行任务，保证所有的任务按照指定顺序（FIFO，LIFO，优先级）执行，所有的任务都保存在队列LinkedBlockingQueue中，等待唯一的单线程来执行任务。
