线程池API及使用

1.1首先思考一下线程是不是越多越好？

1.线程在Java中是一个对象，更是操作系统的资源（本质上来源于底层操作系统），线程创建，销毁需要时间。如果创建时间+销毁时间>执行时间 就很不合算。

2.Java对象占用堆内存，操作系统线程占用系统内存，根据jvm规范，一个线程默认最大栈大小1M,这个栈空间是需要从系统内存中分配的。线程过多，会消耗很多的内存。

3.操作系统需要频繁切换线程上下文（每个线程都想被运行）

线程池的退出，就是为了方便的控制线程池数量

1.2 相关概念

1.线程池管理器：用于创建并管理线程池，包括创建线程池，销毁线程池，添加新任务；

2.工作线程：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；

3.任务接口：每个任务必须实现的接口，以供工作线程调度任务的执行，他主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；

4.任务队列：用于存放没有处理的任务。提供一种缓冲机制。

运行部分理解图（结合概念）

1.3线程池API - 接口和实现类

类型	名称	描述
接口	Exeutor	最上层的即接口，定义了执行任务的execute方法
接口	ExeutorService	继承了Executor接口，扩展了Callable、Future、关闭方法
接口	ScheduledExecutorService	继承了ExecutorService，增加了定时任务相关方法
实现类	ThreadPoolExecutor	基础、标准的线程池实现
实现类	ScheduledThreadPoolExecutor	继承了ThreadPoolExecutor，实现了 ScheduledExecutorService中相关定时任务的方法

可以认为ScheduledThreadPoolExecutor是最丰富的功能

1.3.1 ExeutorService API

方法名称	方法作用
awaitTermination(long timeout,TimeUnit unit)	监测ExecutorService是否已经关闭，直到所有任务完成执行，或超时发生，或当前线程被中断
invokeAll(Collection<? extends Callable> tasks)	执行给定的任务集合，执行完毕后，返回结果
invokeAll(Collection<? extends Callable> tasks, long timeout, TimeUnit unit)	执行给定的任务集合，执行完毕或者超时后，返回结果，其他任务终止
invokeAny(Collection<? extends Callable> tasks)	执行给定的任务，任意一个执行成功则返回结果，其他任务终止
invokeAny(Collection<? extends Callable> tasks, long timeout, TimeUnit unit)	执行给定的入伍，任意一个执行成功或者超时，则返回结果，其他任务终止
isShutdown()	如果此线程池已经关闭，则返回true
isTerminated()	如果关闭后所有任务都已经完成，则返回true
shutdown()	优雅关闭线程池，之前提交的任务将被执行。
shutdownNow()	尝试停止所有正在执行的任务，停止等待任务的处理，并返回等待执行任务的列表。
submit(Callable task)	提交一个用于执行的Callable返回任务，并返回一个Futura，用于获取Callable执行结果
submit(Runnable task)	提交可运行任务以执行，并返回一个Future对象,执行结果为null
submit(Runnable task, T result)	提交可运行任务以执行，并返回一个Future，执行结果为传入的result

ExeutorService 接口位于rt.jar包下的Java/util/concurrent/locks包下面，可以结合接口注释理解一波

1.3.2 ScheduledExecutorService API

方法名称	方法作用
schedule(Runnable command,long delay, TimeUnit unit)	创建并执行一个一次性任务，过了delay的间隔就会自动执行，timeUnit指代的是delay的单位(时分秒或其他)
schedule(Callable callable,long delay, TimeUnit unit)	创建并执行一个一次性任务，过了delay的间隔就会自动执行，timeUnit指代的是delay的单位(时分秒或其他)
scheduleAtFixedRate(Runnable command,long initialDelay, long period,TimeUnit unit)	创建并执行一个周期性任务过了给定的初始延迟时间，会第一时间被执行，执行过程中发生了异常，那么任务时间就停止
scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit)	创建并执行一个周期性任务，过了初始延迟时间，第一次被执行，后续以给定的周期时间执行，执行过程发生了异常，那么任务就停止

scheduleAtFixedRate 与 scheduleWithFixedDelay 的区别在于

scheduleAtFixedRate 当有工作线程空闲时，会立刻将任务队列中的任务放入工作线程中

scheduleWithFixedDelay 当有工作线程空闲时，在空闲的那一刻开始计时延时指定的参数的时间执行下一个线程

1.4 线程池 的使用

1.4.1 线程池的创建

1.4.1.1 构造方法（new）创建线程池

ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue workQueue)

corePoolSize ：核心线程池大小

maximumPoolSize : 最大线程池大小

keepAliveTime : 存活时间

unit ：时间的单位类型（是 时/分/秒 还是其他）

workQueue ：工作队列模式

1.4.1.2 Executors工具类创建线程池

Executors 类位于java.util.concurrent包下（可以 快速 创建线程的一个工具类）

其实就是通过调用 ThreadPoolExecutor 或者 ScheduledThreadPoolExecutor 构造方法，传递不同的参数，常用方法如下：

newFixedThreadPool(int nThreads)创建一个固定大小、任务队列容量无界的线程池。核心线程数=最大线程数。

newCachedThreadPool（）创建的是一个大小无界的缓冲线程池。他的任务队列是一个同步队列。任务加入到池中，如果池中有空闲线程，则用空闲线程执行，如无则创建新线程执行。池中的线程空闲超过60秒，将被销毁释放。线程数随任务的多是变化。适用于执行耗时较小的异步任务。池的核心线程数=0，最大线程数=Integer.MAX_VALUE

newSingleThreadExecutor() 只有一个线程来执行无界任务队列的单一线程池。该线程池确保任务按加入的顺序一个一个依次执行。当唯一的线程因任务异常终止时，将创建一个新的线程来执行后续的任务。与newFixedThreadPool(1)的区别在于，单一线程池的池大小在newSingleThreadExecutor方法中硬编码，不能在改变。

newScheduledThreadPool（int corePoolSize）能定时执行任务的线程池。该池的核心线程数由参数指定，最大线程数=Integer.MAX_VALUE

1.4.1.3 线程池执行原理分析

结合 ThreadPoolExecutor 的 execute 方法 内 的注释 内容可以得出以下结论：

1、是否达到核心线程数量？没达到，创建一个工作线程来执行任务。

2、工作队列是否已满？美满，则将新提交的任务存储在任务队列中。

3、是否达到线程池最大数量？没达到，则创建一个新的工作线程来执行任务。

4、最后，执行拒绝策略来处理这个任务。

1.4.1.4 等待队列类型

该队列的实现有上述类型，常用的队列类型如下

1.LinkedBlockingQueue 当不传参数时候，是无限大小的等待队列，通过有参数的构造方法的时候，为参数大小的等待队列

2.SynchronousQueue，实际上它不是一个真正的队列，因为它不会为队列中元素维护存储空间。与其他队列不同的是，它维护一组线程，这些线程在等待着把元素加入或移出队列

1.5 不同类型等待队列的使用场景

1. 创建测试类
2. 将下列方法写入

	/** 
	* 测试： 提交15个执行时间需要3秒的任务,看线程池的状况 
	*  
	* @param threadPoolExecutor 传入不同的线程池，看不同的结果 
	* @throws Exception 
	*/
public void testCommon(ThreadPoolExecutor threadPoolExecutor) throws Exception {
      
    // 测试： 提交15个执行时间需要3秒的任务，看超过大小的2个，对应的处理情况   
    for (int i = 0; i < 15; i++) {
         
        int n = i;      
        threadPoolExecutor.submit(new Runnable() {
            
            @Override         
            public void run() {
               
                try {
                  
                    System.out.println("开始执行：" + n);               
                    Thread.sleep(3000L);               
                    System.err.println("执行结束:" + n);            
                } catch (InterruptedException e) {
                  
                    e.printStackTrace();            
                }         
            }      
        });      
        System.out.println("任务提交成功 :" + i);   
    }   
    // 查看线程数量，查看队列等待数量   
    Thread.sleep