线程池
Callable接口
相比于runnable接口而言，callable可以抛出异常，并且返回返回值
callable接口基本使用
class Task implements Callable<String> {
@Override
public String call() throws Exception {
System.out.println(Thread.currentThread().getName());
TimeUnit.SECONDS.sleep(5);
return "aaa";
}
}
public class ThreadPoolTest {
public static void main(String[] args)throws Exception {
FutureTask futureTask = new FutureTask(new Task());
Thread thread = new Thread(futureTask);
thread.start();
// futureTask获取不到线程的返回值结果，会一直堵塞线程
System.out.println(futureTask.get());
}
}为什么要使用线程池
我们知道创建线程需要时间和空间。如果使用一次就不在使用，会等待 young GC 回收。当有大量的异步任务时，创建大量线程对象，消耗了时间和堆空间，会导致eden区 更早触发young gc，进一步降低效率。
优点：
降低资源消耗。通过重复利用己创建的线程降低线程创建和销毁造成的消耗。
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
创建线程的四种方式
1、继承Thread
2、实现Runnable
3、实现Callable
4、使用线程池
线程池七大参数
我们以Executors为例
Executors为线程工具类，使用时可以便捷的创建线程。
public static void main(String[] args)throws Exception {
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
System.out.println("固定线程的线程池");
for (int i = 0; i < 5; i++) {
fixedThreadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+" "+ fixedThreadPool.getClass().getName());
});
}
System.out.println("---------------------------");
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
System.out.println("单一线程的线程池");
for (int i = 0; i < 5; i++) {
singleThreadExecutor.execute(()->{
System.out.println(Thread.currentThread().getName()+" "+ singleThreadExecutor.getClass().getName());
});
}
System.out.println("---------------------------");
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
System.out.println("缓存线程的线程池");
for (int i = 0; i < 5; i++) {
singleThreadExecutor.execute(()->{
System.out.println(Thread.currentThread().getName()+" "+ cachedThreadPool.getClass().getName());
});
}
}1、Executors.newFixedThreadPool(3);
固定大小的线程池
2、Executors.newSingleThreadExecutor();
单一线程的线程池
3、Executors.newCachedThreadPool();
可缓存线程的线程池
线程池七大参数
1、corePoolSize 核心线程数（常驻线程）
2、maximumPoolSize 最大线程数 （线程池容纳的最大线程，当堵塞队列和常驻线程都没有空间时，会开启最大线程数-核心线程数得到的线程）
3、keepAliveTime 最大线程数-核心线程数得到的线程 存活的时间
4、TimeUnit 时间单元
5、BlockingQueue 存放线程执行任务的堵塞队列（该队列是线程安全的，当线程池中线程没时间处理任务时，任务进入堵塞队列）
6、ThreadFactory 生产线程的工厂
7、RejectedExecutionHandler 拒绝执行的处理器策略，当maximumPoolSize对应的线程都在执行任务，堵塞队列也满了，对后来的线程的拒绝执行的处理策略
**注意：首次有任务来的时候，创建的是核心线程，该线程不会关闭。
所以上图中第一次 创建核心线程执行任务，第二次创建非核心线程执行任务**
不能使用Executors创建线程
Executors创建的线程，底层都是通过ThreadPoolExecutor创建的，并且使用的是LinkedBlockingQueue队列，默认最大Integer.MAX_VALUE。这意味这，除非没有内存了，不然队列永远满不了。在高并发下，内存中会囤积大量的异步任务，容易发生OOM，线程的执行效率也会变低。
线程池的4种拒绝策略
等待队列也已经排满了，再也塞不下新任务了同时，线程池中的max线程也达到了，无法继续为新任务服务。
这时候我们就需要拒绝策略机制合理的处理这个问题。
JDK拒绝策略：
1、AbortPolicy（默认）：直接抛出 RejectedExecutionException异常阻止系统正常运知。
2、CallerRunsPolicy："调用者运行"一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。
3、DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务。
4、DiscardPolicy：直接丢弃任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种方案。
手写一个线程池
注意：开发中常见的应该是scheduledThreadPoolExecutor+ timerTask
class Task extends TimerTask{
@Override
public void run() {
System.out.println(Thread.currentThread().getName() +"执行任务");
}
}
public static void main(String[] args)throws Exception {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,
5,
1L,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(5),
Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());
// 核心线程 和 blockingQueue 已满会创建 剩下的线程执行
for (int i = 0; i < 8 ; i++) {
threadPoolExecutor.execute(new Task());
}
}**核心线程 和 blockingQueue 已满会创建 剩下的线程执行。
如果max线程 和 blockingQueue 已满会 还有任务要处理，该任务直接丢弃**
合理线程池线程数
CPU密集型
CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。
CPU密集任务只有在真正的多核CPU上才可能得到加速(通过多线程),
而在单核CPU上，无论你开几个模拟的多线程该任务都不可能得到加速，因为CPU总的运算能力就那些。
CPU密集型任务配置尽可能少的线程数量：
一般公式：（CPU核数+1）个线程的线程池
例如：8核+8 = 16
lO密集型
由于IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如CPU核数 * 2。
IO密集型，即该任务需要大量的IO，即大量的阻塞。
在单线程上运行IO密集型的任务会导致浪费大量的CPU运算能力浪费在等待。
所以在IO密集型任务中使用多线程可以大大的加速程序运行，即使在单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间。
IO密集型时，大部分线程都阻塞，故需要多配置线程数：
**参考公式：CPU核数/ (1-阻塞系数)
阻塞系数在0.8~0.9之间
比如8核CPU：8/(1-0.9)=80个线程数**
