Executors创建四种线程池

1、new Thread的弊端

new Thread(new Runable(){
  @Override
  public void run() {
    //
  }
}).start();

new Thread

弊端

每次new Thread 新建对象性能差

线程缺乏统一管理，可以无限制创建线程，相互之间竞争，极可能占用过多系统资源导致OOM

缺乏更多功能，如：定时执行、线程中断等

优点

重用存在的线程，减少对象创建、消亡的开销，性能差

可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免阻塞

提供定时执行、单线程、并发数控制等等

2、Executors 线程池

newCachedThreadPool ：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，否则新建线程。
newFixedThreadPool：创建一个固定大小的线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool ：创建一个定时线程池，支持定时及周期性任务执行。
newSingleThreadExecutor ：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

（1） newCacheThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
示例：

public class MyThreadTest{

    
    public static ExecutorService executor = Executors.newCachedThreadPool();
    //public static ExecutorService executor = Executors.newFixedThreadPool(1);
    public static long fm = System.currentTimeMillis();
    
    public static void main(String[] args) throws InterruptedException {
        System.out.println("main方法开始，活跃线程数：【" + Thread.activeCount() + "】");
        for(int i=0;i<5;i++) { // 开启多个线程
            executor.execute(new ThreadTest(i));
        }
        Thread.sleep(2000);
        System.out.println("主线程睡眠2秒之后============================");
        for(int i=0;i<5;i++) { // 开启多个线程
            executor.execute(new ThreadTest(i));
        }
        //System.out.println("main方法结束，线程数：【" + Thread.activeCount() + "】");
    }
    
    static class ThreadTest implements Runnable {
        
        private int i;
        
        public ThreadTest(final int i){
            this.i = i;
        }

        @Override
        public void run() {
            System.out.println("线程【Thread_" + i + "】开始时间：" + System.currentTimeMillis() + ",睡眠1s");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程【Thread_" + i + "】结束时间：" + System.currentTimeMillis() + ",活跃线程数：【" + Thread.activeCount() + "】,总执行时间【" + (System.currentTimeMillis()-fm) + "】");
        }
    }
}

执行结果：

main方法开始，活跃线程数：【1】
线程【Thread_0】开始时间：1552202572537,睡眠1s
线程【Thread_1】开始时间：1552202572537,睡眠1s
线程【Thread_2】开始时间：1552202572537,睡眠1s
线程【Thread_3】开始时间：1552202572538,睡眠1s
线程【Thread_4】开始时间：1552202572538,睡眠1s
线程【Thread_1】结束时间：1552202573537,活跃线程数：【6】,总执行时间【1002】
线程【Thread_0】结束时间：1552202573537,活跃线程数：【6】,总执行时间【1002】
线程【Thread_4】结束时间：1552202573538,活跃线程数：【6】,总执行时间【1003】
线程【Thread_2】结束时间：1552202573538,活跃线程数：【6】,总执行时间【1003】
线程【Thread_3】结束时间：1552202573538,活跃线程数：【6】,总执行时间【1003】
主线程睡眠2秒之后============================
线程【Thread_2】开始时间：1552202574551,睡眠1s
线程【Thread_1】开始时间：1552202574551,睡眠1s
线程【Thread_0】开始时间：1552202574551,睡眠1s
线程【Thread_3】开始时间：1552202574551,睡眠1s
线程【Thread_4】开始时间：1552202574551,睡眠1s
线程【Thread_2】结束时间：1552202575551,活跃线程数：【6】,总执行时间【3016】
线程【Thread_4】结束时间：1552202575551,活跃线程数：【6】,总执行时间【3016】
线程【Thread_3】结束时间：1552202575551,活跃线程数：【6】,总执行时间【3016】
线程【Thread_0】结束时间：1552202575551,活跃线程数：【6】,总执行时间【3016】
线程【Thread_1】结束时间：1552202575551,活跃线程数：【6】,总执行时间【3016】

可以看到main 方法执行是，线程数为1（main 主线程），设置每个线程睡眠1s，同时开启5个子线程，总的执行时间为1s，总线程数为6个。主线程睡眠2s后，再次执行线程方法时，可以看到活跃线程数同样为6，说明此时线程池中缓存了第一次创建的5个。

（2）newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
示例：将上面示例代码中，更改为固定线程池的创建
执行结果：
main方法开始，活跃线程数：【1】
线程【Thread_0】开始时间：1552202901503,睡眠1s
线程【Thread_0】结束时间：1552202902504,活跃线程数：【2】,总执行时间【1003】
线程【Thread_1】开始时间：1552202902504,睡眠1s
主线程睡眠2秒之后============================
线程【Thread_1】结束时间：1552202903504,活跃线程数：【2】,总执行时间【2003】
线程【Thread_2】开始时间：1552202903504,睡眠1s
线程【Thread_2】结束时间：1552202904505,活跃线程数：【2】,总执行时间【3004】
线程【Thread_3】开始时间：1552202904505,睡眠1s
线程【Thread_3】结束时间：1552202905505,活跃线程数：【2】,总执行时间【4004】
线程【Thread_4】开始时间：1552202905505,睡眠1s
线程【Thread_4】结束时间：1552202906505,活跃线程数：【2】,总执行时间【5004】
线程【Thread_0】开始时间：1552202906505,睡眠1s
线程【Thread_0】结束时间：1552202907505,活跃线程数：【2】,总执行时间【6004】
线程【Thread_1】开始时间：1552202907505,睡眠1s
线程【Thread_1】结束时间：1552202908505,活跃线程数：【2】,总执行时间【7004】
线程【Thread_2】开始时间：1552202908505,睡眠1s
线程【Thread_2】结束时间：1552202909505,活跃线程数：【2】,总执行时间【8004】
线程【Thread_3】开始时间：1552202909505,睡眠1s
线程【Thread_3】结束时间：1552202910505,活跃线程数：【2】,总执行时间【9004】
线程【Thread_4】开始时间：1552202910505,睡眠1s
线程【Thread_4】结束时间：1552202911506,活跃线程数：【2】,总执行时间【10005】

可以看到，总的执行时间为10s，而且活跃的线程数为2（其中一个为主线程main）

（3）newScheduledThreadPool
A : 创建一个定长线程池，支持定时及周期性任务执行, 注意应用接口的不同

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {

  @Override
  public void run() {
      System.out.println("delay 3 seconds");
  }
}, 3, TimeUnit.SECONDS);

表示延迟3秒执行
B : 定期执行示例代码如

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
  
    @Override
    public void run() {
        System.out.println("delay 1 seconds, and excute every 3 seconds");
    }
}, 1, 3, TimeUnit.SECONDS);

表示延迟1秒后每3秒执行一次
ScheduledExecutorService比Timer更安全，功能更强大。

（4）newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

3、线程池

A：作用：

线程池作用就是限制系统中执行线程的数量

根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等待。一个任务执行完毕，再从队列中取最前面的任务开始执行。若队列中没有等待线程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。

B：为什么要使用？

减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2.可以根据系统的承受能力，吊针线程池中工作线程的数目，防止因为消耗过多的内存，而把服务器累趴下

C：使用
Java里面线程池的顶级接口是Executor，但议案个意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。
比较重要的几个类：

类/接口	描述
ExecutorService	真正的线程池接口
ScheduledExecutorService	能和Timer/TimerTask类似，解决那些需要任务重复执行的问题
ThreadPoolExecutor	ExecutorService的默认实现
ScheduledThreadPoolExecutor	继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

newSingleThreadExecutor

创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

2.newFixedThreadPool

创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

newCachedThreadPool

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，

那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

4.newScheduledThreadPool

创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

参考文档：
https://www.cnblogs.com/baizhanshi/p/5469948.html