一. 问题引入

      我们知道可以用1.继承Thread类 2.实现runnable接口两种方法创建一个线程，这样实现起来很方便，但是同样出现了一个问题：

      如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，

因为频繁创建线程和销毁线程需要时间。

      那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？

      在Java中可以通过线程池来达到这样的效果！

 

二. 线程池简介

① Jdk1.5之后加入了java.util.concurrent包，这个包中主要介绍java中线程以及线程池的使用。为我们在开发中处理线程的问题提供了非常大的帮助。

② 线程池工作原理: 

1. 线程池是一种预先创建线程的技术，线程池在还没有任务到来时预先创建一定数量的线程，放入空闲队列中。

    这些线程都处于睡眠状态，不消耗CPU，所以只是占用比较少的内存

2. 当请求到来后，线程池给这次请求分配一个空闲线程，把请求传入线程中进行处理

3. 当线程池预先设置的线程数目不能满足需求出现太多或者太少，可以通过手动调整

③ 线程池的好处

1. 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

2. 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

3. 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

 

三.  线程池入门

1. 线程池体系结构分析

① Java里面线程池的顶级接口是Executor，在它里面只声明了一个方法execute(Runnable)，从字面意思可以理解，就是用

来执行传进去的任务的；

② 而真正的线程池接口是ExecutorService接口，ExecutorService接口继承了Executor接口，并声明了一些方法：submit、

invokeAll、invokeAny以及shutDown等；

③ 抽象类AbstractExecutorService实现了ExecutorService接口，基本实现了ExecutorService中声明的所有方法；

④ ThreadPoolExecutor继承了类AbstractExecutorService，我们需要明白:ThreadPoolExecutor是最核心的一个类

里面有几个重要的方法:

- execute()方法实际上是Executor中声明的方法，在ThreadPoolExecutor进行了具体的实现，这个方法是ThreadPoolExecutor的核心方法，

通过这个方法可以向线程池提交一个任务，交由线程池去执行。

- submit()方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并没有对其进行重写，这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，去看submit()方法的实现，会发现它实际上还是调用的execute()方法，只不过它利用了Future来获取任务执行结果

- shutdown()和shutdownNow()是用来关闭线程池的。

- getQueue() 、getPoolSize() 、getActiveCount()、getCompletedTaskCount()等获取与线程池相关属性的方法(自行了解)

2. 开启线程池

在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

1. newSingleThreadExecutor

创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一

个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

2.newFixedThreadPool

创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个

线程因为执行异常而结束，那么线程池会补充一个新线程。

3. newCachedThreadPool

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

4.newScheduledThreadPool

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

 

实例1： newSingleThreadExecutor

public class MyThread extends Thread {

      @Override

      publicvoid run() {

      System.out.println(Thread.currentThread().getName() + "正在执行。。。");

      }

}

 

public class TestSingleThreadExecutor {

    publicstaticvoid main(String[] args) {

        //创建一个可重用固定线程数的线程池

        ExecutorService pool = Executors. newSingleThreadExecutor();

        //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口

        Thread t1 = new MyThread();

        Thread t2 = new MyThread();

        Thread t3 = new MyThread();

        Thread t4 = new MyThread();

        Thread t5 = new MyThread();

        //将线程放入池中进行执行

        pool.execute(t1);

        pool.execute(t2);

        pool.execute(t3);

        pool.execute(t4);

        pool.execute(t5);

        //关闭线程池

        pool.shutdown();

    }

}

结果

 

pool-1-thread-1正在执行。。。

 

pool-1-thread-1正在执行。。。

 

pool-1-thread-1正在执行。。。

 

pool-1-thread-1正在执行。。。

 

pool-1-thread-1正在执行。。。

 

 

3. ThreadPoolExecutor详解

ThreadPoolExecutor的完整构造方法的签名是：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,TimeUnit unit,

BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory, RejectedExecutionHandler handler)

参数1：corePoolSize - 核心池的大小(基本池的大小)当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执

行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的prestartAllCoreThreads方法，线程池会提前创

建并启动所有基本线程。

参数2：maximumPoolSize-池中允许的最大线程数。

参数3: keepAliveTime - 表示线程没有任务执行时最多保持多久时间会终止,默认情况下，只有当线程池中的线程数大于corePoolSize时，

keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到

keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。

参数4：unit - 参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：

TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒

参数5： workQueue - 用于保存等待执行的任务的阻塞队列。  可以选择以下几个阻塞队列:

 

      • ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。
      • LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。
      • SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。
      • PriorityBlockingQueue：一个具有优先级的无限阻塞队列。

 

参数6：ThreadFactory - 用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字。

参数7： handler - 当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，

表示无法处理新任务时抛出异常。以下是JDK1.5提供的四种策略。

      • AbortPolicy：直接抛出异常。
      • CallerRunsPolicy：只用调用者所在线程来运行任务。
      • DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
      • DiscardPolicy：不处理，丢弃掉。

 4. 向线程池提交任务的两种方法

① 使用execute提交任务，但是execute方法没有返回值，所以无法判断任务是否被线程池执行成功。

通过以下代码可知execute方法输入的任务是一个Runnable类的实例。

       threadsPool.execute(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
            }
       });
      ② 使用submit方法提交任务，它会返回一个future,那么我们可以通过这个future来判断任务是否执行成功，通过future的get方法来获取返回
      值，get方法会阻塞住直到任务完成，成功完成时会返回null,而使用get(long timeout, TimeUnit unit)方法则会阻塞一段时间后立即返回，      这时有可能任务没有执行完。
Future<Object> future = executor.submit(harReturnValuetask);
try {
     Object s = future.get();
} catch (InterruptedException e) {
    // 处理中断异常
} catch (ExecutionException e) {
    // 处理无法执行任务异常
} finally {
    // 关闭线程池
    executor.shutdown();
}
5. 线程池的关闭

我们可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池，它们的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方

法来中断线程，所以无法响应中断的任务可能永远无法终止。但是它们存在一定的区别，shutdownNow首先将线程池的状态设置成STOP，然后尝试

停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表，而shutdown只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有

正在执行任务的线程。

只要调用了这两个关闭方法的其中一个，isShutdown方法就会返回true。当所有的任务都已关闭后,才表示线程池关闭成功，这时调用isTerminaed方

法会返回true。至于我们应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown来关闭线程池，如果任务不一

定要执行完，则可以调用shutdownNow。

四. 线程池工作原理分析

从上图我们可以看出，当提交一个新任务到线程池时，线程池的处理流程如下：

    1. 首先线程池判断基本线程池是否已满？没满，创建一个工作线程来执行任务。满了，则进入下个流程。
    2. 其次线程池判断工作队列是否已满？没满，则将新提交的任务存储在工作队列里。满了，则进入下个流程。
    3. 最后线程池判断整个线程池是否已满？没满，则创建一个新的工作线程来执行任务，满了，则交给饱和策略来处理这个任务