为什么用线程池，它的优势是什么？

可以装X的方式，使用线程来看下电脑的核数：

public class MyThreadPoolDemo {
    public static void main(String[] args) {
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

在这里插入图片描述
以前创建一个线程都是使用new Thread();的方法。线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。

主要特点：线程复用；控制最大并发数；管理线程。

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

线程池的底层分析

Java中的线程池是通过Executor框架实现的，该框架中用到了Executor，Executors，ExecutorService，ThreadPoolExecutor类。

底层架构

在这里插入图片描述

编码实现

了解：

Executors.newScheduledThreadPool()
java8新出 Executors.newWorkStealingPool(int)
以上两个看过就可以了，不需要深入。在面试时候也不需要说有五种实现，只需要说有三种就可以了。

重点：

Executors.newFixedThreadPool(int) ---------------固定个数的线程池

适用场景：执行长期的任务，性能好很多

Executors.newSingleThreadExecutor()----------------只有一个线程的线程池

适用场景：一个任务一个任务执行的场景

Executors.newCachedThreadPool()-----------------可扩容的带有缓存的一池多线程

适用场景：执行很多短期异步的小程序或者负载较轻的服务器

public class MyThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(5);//一池五个处理线程
        ExecutorService threadPool = Executors.newSingleThreadExecutor();//一池一线程
 		ExecutorService threadPool = Executors.newCachedThreadPool();//一池多线程

        //模拟10个用户来办理业务，每个用户就是一个来自外部的请求线程
        try{
            for (int i = 0; i < 10; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"\t办理业务");
                });
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            threadPool.shutdown();
        }
    }
}

源码和七个参数（五个参数）

 public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
 public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

从源码中我们可以看到，三种重要的实现都是new ThreadPoolExecutor，并且五个参数的最后一个都与阻塞队列有关。再点入到ThreadPoolExecutor的源码，发现总共有七个参数。

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

参数	作用
corePoolSize	核心线程池大小
maximumPoolSize	最大线程池大小
keepAliveTime	线程池中超过 corePoolSize 数目的空闲线程最大存活时间；可以allowCoreThreadTimeOut(true) 使得核心线程有效时间
unit	keepAliveTime 时间单位
workQueue	阻塞任务队列
threadFactory	新建线程工厂
handler	当提交任务数超过 maxmumPoolSize+workQueue 之和时，任务会交给RejectedExecutionHandler 来处理