一、说明

线程池的引出

• 通过new语句创建一个Java对象时，JVM就会为这个对象分配一块内存空间
• 而线程的创建和销毁需要调用操作系统内核的API，成本较高
• 线程池是一个容纳多个线程的容器，通过复用线程来达到执行多个任务的目的，对线程进行统一的分配，调优和监控，无需重复创建线程，优化了资源开销，由此引出Executor框架

二、理解

Executor

• java.util.cocurrent 包下Executor接口，内部使用线程池机制，控制线程的启动、执行和关闭，相比Thread.start()方法效率更高，易于管理

包括三大部分

• 任务：被执行任务需要实现Callable 和 Runnable接口
• 任务的执行：把任务分派给多个线程的执行机制， Executor和ExecutorService接口及其实现类
• 异步计算的结果： Future 接口 FutureTask实现类

• Executor即线程池接口，其execute()方法接收Runnable接口的对象，但没有返回结果
• ExecutorService 接口用来实现和管理多线程，提供生命周期管理方法，返回 Future 对象，当所有已经提交的任务执行完毕后将会关闭该接口
• AbstractExecutorService 类用来提供线程接口的一些默认实现
• ThreadPoolExecutor 线程池的实现类，通过调用Executors创建线程池并返回一个ExecutorService对象
• ScheduledExecutorService 接口用来执行定时任务
• ScheduledThreadPoolExecutor 用来调度定时任务的线程池实现类

Executor框架使用流程

ExecutorService

• 继承 Executor 接口
• submit()方法接收Runnable和Callable接口的对象，有返回执行结果的对象
• 关闭线程池调用 shutDown() 方法停止接收新任务，原来的任务继续执行；或者shutdownNow()方法停止接收新任务，原来的任务停止执行

Executors

• 线程池工厂类，提供生成Executor(线程池)的方法，返回的线程池都实现了ExecutorService接口

• newSingleThreadExecutor() 创建单个线程的线程池

• newFixedThreadPool(int numOfThreads) 创建固定线程数的线程池，可控制线程最大并发数，超出的线程会在队列中等待

• newCachedThreadPool() 根据需要创建新的线程，自动回收空闲线程，所有线程都会在限制60秒后被回收，如果回收后又创建了任务，将新创建一个线程

• newScheduledThreadPool(int) 创建一个支持定时及周期性执行任务的线程池

三、实现

1. newSingleThreadExecutor

创建一个SingThreadExecutorTest类，单个线程的线程池执行MyThread1和MyThread2任务

public class SingThreadExecutorTest {
    public static void main(String[] args) {
        // 1.创建一个单线程化的线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        // 2.创建10次线程任务
        for (int i = 0; i < 5; i++) {
            // 3.执行线程任务
            executorService.execute(new MyThread1());
            executorService.execute(new MyThread2());
        }
        // 4.关闭线程池
        executorService.shutdown();
    }
    static class MyThread1 extends Thread {
        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + "        我是任务1");
                sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
    static class MyThread2 extends Thread {
        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + " 我是任务2");
                sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

只有单个线程池去执行10个任务

2. newFixedThreadPool

创建固定线程数的线程池，可控制线程最大并发数，超出的线程会在队列中等待

    public static void main(String[] args) {
        // 1.创建容量为5线程数的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        // 2.创建10次线程任务
        for (int i = 0; i < 5; i++) {
            // 3.执行线程任务
            executorService.execute(new MyThread1());
            executorService.execute(new MyThread2());
        }
        // 4.关闭线程池
        executorService.shutdown();
    }

5个线程去执行10个任务

3. newCachedThreadPool

根据需要创建新的线程，自动回收空闲线程，所有线程都会在限制60秒后被回收，如果回收后又创建了任务，将新创建一个线程

    public static void main(String[] args) {
        // 1.创建可缓存的线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        // 2.创建10次线程任务
        for (int i = 0; i < 5; i++) {
            // 3.执行线程任务
            executorService.execute(new MyThread1());
            executorService.execute(new MyThread2());
        }
        // 4.关闭线程池
        executorService.shutdown();
    }

根据需要自动创建新线程去只执行10个任务

当线程运行时间超过60秒时

    public static void main(String[] args) throws InterruptedException {
        // 1.创建可缓存的线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        // 2.创建线程任务执行
        for (int i = 0; i < 5; i++) {
            executorService.execute(new MyThread1());
        }
        Thread.sleep(30000);
        System.out.println("睡眠30秒");
        for (int i = 0; i < 5; i++) {
            executorService.execute(new MyThread1());
        }
        Thread.sleep(65000);
        System.out.println("睡眠65秒");
        for (int i = 0; i < 5; i++) {
            executorService.execute(new MyThread1());
        }
        // 4.关闭线程池
        executorService.shutdown();
    }

5个线程执行任务再休眠30秒后，线程并未被回收，继续用这5个线程执行任务，休眠65秒后，线程被回收，新建5个线程执行任务

4. newScheduledThreadPool

创建一个支持定时及周期性执行任务的线程池

public class SingThreadExecutorTest {
    public static void main(String[] args) {
        // 1.创建容量为5线程数的线程池
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);
        // 2.创建10次线程任务
        for (int i = 0; i < 5; i++) {
            // 3.执行线程任务
            executorService.schedule(new MyThread1(),5000 , TimeUnit.MILLISECONDS);
            executorService.schedule(new MyThread2(),1000 , TimeUnit.MILLISECONDS);
        }

5个线程去执行10个任务，任务2马上就执行完成了，而任务1要延迟5秒才执行完成