为什么使用线程池：
1、创建/销毁线程伴随着系统开销，过于频繁的创建/销毁线程，会很大程度上影响处理效率。
2、线程并发数量过多，抢占系统资源从而导致阻塞。
3、对线程进行一些简单的管理。
在java中，线程池的类为ThreadPoolExecutor，首先来看一下该类的继承关系
大抵所有的线程池都是来自于Executor接口，这个接口里面定义了线程池的抽象方法：
void execute(Runnable command);
在Executor接口之后的是ExecutorServer接口，里面定义了一些submit()、shutdown()方法。
然后我们来看一下ThreadPoolExecutor类提供的四种构造方法：
//五个参数的构造函数 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) //六个参数的构造函数-1 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) //六个参数的构造函数-2 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) //七个参数的构造函数 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
方法中的参数：
int corePoolSize 线程池中核心线程大小
在线程池中的线程小于核心线程数时，则新建的线程属于核心线程，否则属于非核心线程。默认情况下，核心线程会一直存货于线程池，即使什么也不做。但如果指定类中的allowCoreThreadTimeOut为true，则核心线程闲置一定时间后也会被销毁，具体时间，由参数指定。
int maximumPoolSize 线程池中最大线程数
线程池中存在的线程数量不会超过最大线程数，如果在达到最大线程数后仍有新的任务需要执行，则会进行排队。
long keepAliveTime 非核心线程的最大存活时间
线程池中的非核心线程处于闲置状态时，则会开始计时，达到指定时间后将被销毁。如果指定参数allowCoreThreadTimeOut为true，则核心线程同样适用。
TimeUnit unit keepAliveTime的单位
类型TimeUnit是枚举类型，包括
NANOSECONDS ： 1微毫秒 = 1微秒 / 1000
MICROSECONDS ： 1微秒 = 1毫秒 / 1000
MILLISECONDS ： 1毫秒 = 1秒 /1000
SECONDS ： 秒
MINUTES ： 分
HOURS ： 小时
DAYS ： 天
BlockingQueue<Runnable> workQueue 任务队列
等待执行的Runnable对象所组成的队列。如果所有核心线程都正在执行，则任务会进行队列。如果队列满了，则新建非核心线程。
常用的workQueue类型：
SynchronousQueue：这个队列接收任务后直接提交给线程处理而不会保留它。为了避免线程数量达到maximumPoolSize而无法新建新的线程，通常将maximumPoolSize设置为Integer.MAX_VALUE，即无限大。
LinkedBlockingQueue：这个队列接收任务后，将任务交给核心线程处理，如果没有空闲的核心线程，则会保留在队列中。由于该队列没有数量限制，因此线程数永远不会超过核心线程数，即maximumPoolSize无效。
ArrayBlockingQueue：这个队列与LinkedBlockingQueue的区别在于有数量限制，当队列已满后将新建非核心线程，如果总线程数达到maximumPoolSize，则发生错误。
DelayQueue：队列内元素必须实现delayed接口，即传进去的任务必须先实现delayed接口。接收到的任务会先进入队列，达到了指定的延时时间，才会执行任务。
ThreadFactory threadFactory 创建线程的方式。
这是一个接口，new的时候需要实现Thread newThread(Runnable r)方法。
RejectedExecutionHandler handler 异常
用来抛出异常，如发生异常，则由该异常对象抛出信息，即使不指定也会有个默认值。
向线程池添加任务
ThreadPoolExecutor.execute(Runnable command) //这个方法是在ThreadPoolExcutor中重写，没有返回结果的添加线程任务
// 这个方法也可以被用来往线程池中添加线程任务。不同处在于它是定义在AbstractExecutorServer中，在ThreadPoolExecutor中没有再重写它。 public Future<?> submit(Runnable task) { if (task == null) throw new NullPointerException(); RunnableFuture<Void> ftask = newTaskFor(task, null); execute(ftask); //内部仍是调用了execute()方法。 return ftask; }
ThreadPoolExecutor的策略
当一个任务被添加进线程池后：
1、线程数未达到核心线程数，新建一个核心线程数。
2、线程数已达到核心线程数，任务保留进队列。
3、线程数已达到核心线程数，任务队列已满，新建一个非核心线程数。
4、线程数已达到最大线程数，任务队列已满，抛出异常。
常见的四种线程池
(在阿里巴巴JAVA开发手册中是不建议通过Executors来创建这些配置好的线程池)
java对线程池类ThreadPoolExecutor进行了封装，提供了常用的四种线程池。这四种线程池都是或直接或间接配置ThreadPoolExecutor的参数实现。
1、CachedThreadPool() 可缓存线程池
- 线程数无限
- 有空闲线程则使用空闲线程，否则创建新线程
- 一定程度上减少创建/销毁线程的开销
创建方法
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
源码
public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); }
2、FixedThreadPool() 定长线程池
- 可控制线程最大并发数
- 超出的线程会在队列中等待
创建方法
//nThreads => 最大线程数即maximumPoolSize ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads); //threadFactory => 创建线程的方法 ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory);
源码
public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); }
3、ScheduledTheadPool() 定长线程池
- 支持定时周期性的执行任务
创建方法
//nThreads => 最大线程数即maximumPoolSize ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(int corePoolSize);
源码
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) { return new ScheduledThreadPoolExecutor(corePoolSize); } //ScheduledThreadPoolExecutor(): public ScheduledThreadPoolExecutor(int corePoolSize) { super(corePoolSize, Integer.MAX_VALUE, DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS, new DelayedWorkQueue()); }
4、SingleThreadExecutor() 单线程线程池
有且仅有一个工作线程执行任务
所有任务按照指定顺序执行，即遵循队列的出队入队规则。
创建方法
ExecutorService singleThreadPool = Executors.newSingleThreadPool();
源码
public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); }
ThreadPoolExecutor任务拒绝策略
ThreadPoolExecutor里面定义了4个静态内部类，用来标识不同的异常类型：
ThreadPoolExecutor.AbortPolicy //拒绝接收任务并抛出rejectedExecuption ThreadPoolExecutor.DiscardPolicy //拒绝接收任务，但不抛出任何异常 ThreadPoolExecutor.DiscardOldestPolicy //将等待队列中的第一个任务抛弃，接收新的线程任务。 ThreadPoolExecutor.CallerRunsPolicy //由调用线程处理该任务。
下面我们来分别用代码测试一下这几种任务拒绝策略
public void testThreadPoolRejectedPoicy(RejectedExecutionHandler handler) {
// 先定义一个线程池，核心线程数2，最大线程数4，非核心线程过期时间10分钟，队列最大任务数2.
ThreadPoolExecutor te = new ThreadPoolExecutor(2,4,10, TimeUnit.MINUTES, new ArrayBlockingQueue<>(2), handler);
// 一次性添加20个任务进入线程池，由于我们配置的线程池最大只能接收6个任务，因此一旦超过6个就会触发拒绝策略 for (int i = 0; i < 20; i++) {
final int j = i; te.execute(new Runnable() { @Override public void run() { try { System.out.println("当前线程" + Thread.currentThread() + "正在执行" + j + "！" + new Date()); Thread.sleep(5 * 1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); }
测试第一个任务拒绝策略
AbortPolicy ：
testThreadPoolRejectedPoicy(new ThreadPoolExecutor.AbortPolicy());
返回结果：线程池中添加的任务超出了6个，抛出异常，并拒绝接收，可以看到打印出来的i是从0到5。
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task Main5$1@681a9515 rejected from java.util.concurrent.ThreadPoolExecutor@3af49f1c[Running, pool size = 4, active threads = 4, queued tasks = 2, completed tasks = 0] at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047) at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823) at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369) at Main5.testThreadPoolRejectedPoicy(Main5.java:25) at Main5.main(Main5.java:14) 当前线程Thread[pool-1-thread-4,5,main]正在执行5！Thu May 09 10:37:41 CST 2019 当前线程Thread[pool-1-thread-1,5,main]正在执行0！Thu May 09 10:37:41 CST 2019 当前线程Thread[pool-1-thread-2,5,main]正在执行1！Thu May 09 10:37:41 CST 2019 当前线程Thread[pool-1-thread-3,5,main]正在执行4！Thu May 09 10:37:41 CST 2019 当前线程Thread[pool-1-thread-4,5,main]正在执行2！Thu May 09 10:37:46 CST 2019 当前线程Thread[pool-1-thread-1,5,main]正在执行3！Thu May 09 10:37:46 CST 2019
测试第二个任务拒绝策略
DiscardPolicy ：
testThreadPoolRejectedPoicy(new ThreadPoolExecutor.DiscardPolicy ());
返回结果：和AbortPolicy区别只在于没有抛出异常。
当前线程Thread[pool-1-thread-2,5,main]正在执行1！Thu May 09 10:40:00 CST 2019 当前线程Thread[pool-1-thread-3,5,main]正在执行4！Thu May 09 10:40:00 CST 2019 当前线程Thread[pool-1-thread-4,5,main]正在执行5！Thu May 09 10:40:00 CST 2019 当前线程Thread[pool-1-thread-1,5,main]正在执行0！Thu May 09 10:40:00 CST 2019 当前线程Thread[pool-1-thread-3,5,main]正在执行3！Thu May 09 10:40:05 CST 2019 当前线程Thread[pool-1-thread-2,5,main]正在执行2！Thu May 09 10:40:05 CST 2019
测试第三个任务拒绝策略
DiscardOldestPolicy ：
testThreadPoolRejectedPoicy(new ThreadPoolExecutor.DiscardOldestPolicy());
返回结果：在这里，首先执行前4个线程任务，同时还会有2两个线程任务存放在队列中等待竞争。此时第7个任务进来，将队列中的第一个任务丢弃，将第7个任务添加进队列，第8个，第9个一直如此，直到第19个任务被添加进来，此时队列中的两个任务只剩下了18和19。其余的任务已经都被丢弃。因此等到前面4个任务执行完成后，第18和19个任务开始执行。
当前线程Thread[pool-1-thread-3,5,main]正在执行4！Thu May 09 10:41:36 CST 2019 当前线程Thread[pool-1-thread-1,5,main]正在执行0！Thu May 09 10:41:36 CST 2019 当前线程Thread[pool-1-thread-2,5,main]正在执行1！Thu May 09 10:41:36 CST 2019 当前线程Thread[pool-1-thread-4,5,main]正在执行5！Thu May 09 10:41:36 CST 2019 当前线程Thread[pool-1-thread-3,5,main]正在执行18！Thu May 09 10:41:41 CST 2019 当前线程Thread[pool-1-thread-2,5,main]正在执行19！Thu May 09 10:41:41 CST 2019
测试第四个任务拒绝策略：
CallerRunsPolicy ：
testThreadPoolRejectedPoicy(new ThreadPoolExecutor.CallerRunsPolicy());
返回结果：任务比较多就只取了前面部分。可以看到线程池中一直有4个线程在执行任务，并且队列中也保持了两个任务等待。此时添加了新的任务进来，会交由当前线程(我是在main方法中执行，因此是main线程)执行任务。当main线程执行任务的时候，会与往线程池中添加新任务处于竞争状态。在这种情况下，20个线程任务会被一直执行到全部完成。
当前线程Thread[pool-1-thread-3,5,main]正在执行4！Thu May 09 11:06:43 CST 2019 当前线程Thread[pool-1-thread-2,5,main]正在执行1！Thu May 09 11:06:43 CST 2019 当前线程Thread[pool-1-thread-4,5,main]正在执行5！Thu May 09 11:06:43 CST 2019 当前线程Thread[pool-1-thread-1,5,main]正在执行0！Thu May 09 11:06:43 CST 2019 当前线程Thread[main,5,main]正在执行6！Thu May 09 11:06:43 CST 2019 当前线程Thread[pool-1-thread-2,5,main]正在执行3！Thu May 09 11:06:48 CST 2019 当前线程Thread[pool-1-thread-3,5,main]正在执行2！Thu May 09 11:06:48 CST 2019 当前线程Thread[pool-1-thread-4,5,main]正在执行7！Thu May 09 11:06:48 CST 2019 当前线程Thread[pool-1-thread-1,5,main]正在执行8！Thu May 09 11:06:48 CST 2019 当前线程Thread[main,5,main]正在执行9！Thu May 09 11:06:48 CST 2019
……
……