线程池：重点 三大方法 七大参数 四种拒绝策略
使用池化技术的理由：
我们的程序伴随着创建销毁线程十分浪费资源，
所以使用线程池，先创建线程，随用随取，用完归还
简单来说就是节约了资源。
使用线程池的好处：节省资源（最大并发线程数可控）；提高了响应速度；方便管理
三大方法：
1.newFixedThreadPool(线程数):创建指定数量线程的线程池
2.newSingleThreadExecutor():创建单线程的线程池
3.newCacheThreadPool():随着请求的增多线程也随之创建，遇强则强
我们之前都是用Executors创建线程池的，但是到了后期强制不可以用
因此现在用ThreadPoolExecutor创建线程池
为什么不能使用Executors创建线程池呢？
1.FixedThreadPool和SingleThreadPool允许的请求队列的长度很大，约为21亿，
所以可能堆积大量的请求，导致oom
2.CachedThreadPool允许创建的线程数量很大，可能会导致创建大量的线程，从而导致oom
代码如下：
public static void main(String[] args) {
// 三大方法之一：创建指定的线程数
ExecutorService threadPool = Executors.newFixedThreadPool(5);
//三大方法之二：创建单个线程
//ExecutorService threadPool = Executors.newSingleThreadExecutor();
//三大方法之三：随之创建，遇强则强
//ExecutorService threadPool = Executors.newCachedThreadPool();
//使用线程池创建线程
try {
for (int i = 0; i < 100; i++) {
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+"ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//使用完毕，关闭线程池
threadPool.shutdown();
}
}
七大参数：
1.corePoolSize： 核心线程数，一直存活，即使线程数小于核心线程数的时候，
线程数有空闲，线程池也会创建新的线程。
2.maximumPoolSize：最大线程数，当线程数大于核心线程数的时候并且任务队列已经满了的时候，
线程池会创建新的线程，当线程数大于最大线程数的时候并且任务队列已经满了，
会抛出异常。
3.keepAliveTime： 线程空闲时间：当线程的空闲时间达到keepAliveTime时，线程会退出，
直到线程数等于核心线程数，如果allowCoreThreadTimeout=true，
则会直到线程数为0。
4.TimeUnit unit 超时时间单位。
5.BlockingQueue<Runnable> workQueue：
阻塞队列，任务队列的容量。
6.ThreadFactory threadFactory：
线程工厂，基本不用设置。
7.RejectedExecutionHandler handler：
拒绝策略，任务拒绝处理器。
public ThreadPoolExecutor( int corePoolSize,//核心线程数
int maximumPoolSize,//最大线程数
long keepAliveTime,//超时无人调用就会释放
TimeUnit unit,//超时时间单位
BlockingQueue<Runnable> workQueue,//阻塞队列
ThreadFactory threadFactory,//线程工厂-不用动
RejectedExecutionHandler handler)//拒绝策略 {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
四种拒绝策略：
1.new ThreadPoolExecutor..AbortPolicy():线程池满了，还有线程想加入，不处理这个请求，跑出异常
2.new ThreadPoolExecutor.CallerRunsPolicy()：如果任务被拒绝，则通过调用它线程执行此任务，哪来的回哪去
3.new ThreadPoolExecutor.DiscardPolicy()：队列满了，丢掉任务，不会抛出异常
4.new ThreadPoolExecutor.DiscardOldestPolicy()：队列满了，尝试去和最早的竞争，不会抛出异常
IO密集型，CPU密集型：（调优）
public static void main(String[] args) {
// 自定义线程池！工作 ThreadPoolExecutor
// 最大线程到底该如何定义
// 1、CPU 密集型，几核，就是几，可以保持CPu的效率最高！
// 2、IO 密集型 > 判断你程序中十分耗IO的线程，
// 程序 15个大型任务 io十分占用资源！
// 获取CPU的核数
System.out.println(Runtime.getRuntime().availableProcessors());
ExecutorService threadPool = new ThreadPoolExecutor(
2,
Runtime.getRuntime().availableProcessors(),
3,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardOldestPolicy()); //队列满了，尝试去和
最早的竞争，也不会抛出异常！
try {
// 最大承载：Deque + max
// 超过 RejectedExecutionException
for (int i = 1; i <= 9; i++) {
// 使用了线程池之后，使用线程池来创建线程
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+" ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 线程池用完，程序结束，关闭线程池
threadPool.shutdown();
}
}