线程池
- 一、线程池的概念
- 二、线程池原理
- 三、线程池API
- 1.接口定义和实现类
- 2.方法定义
- 3.任务执行过程
- 4.Excutors 工具类（创建线程）
- 四、如何确定线程数量
一、线程池的概念
线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。
技术背景
1.线程在Java中是一个对象，更是操作系统的资源，线程创建，销毁需要时间。如果创建时间+销毁时间>执行任务的时间 就很不划算。
2.Java对象占用堆内存，操作系统线程占用系统内存，根据JVM规范，一个贤臣默认最大栈大小为1M，这个栈空间是需要从系统内存中分配，线程过多，占用的内存就越大。
3.操作系统需要频繁切换上下文（大家都想被运行），影响性能。
应用场景
1、需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。
2、对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。
3、接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限，并出现"OutOfMemory"的错误。
二、线程池原理
线程池组成部分
1、线程池管理器：用于创建并管理线程池，包括创建、销毁线程池，添加新任务；
2、工作线程：指线程池中线程，在没有任务时处于等待状态，在有任务的时候可以循环的执行任务；
3、任务接口：每个任务必须实现的接口，以供工作线程调度任务的执行，主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；
4、任务队列：用于存放没有处理的任务，提供一种缓冲机制。
如下图所示，有一堆实现了任务接口的任务等着被CPU执行，有线程池同一管理的线程来分批运输这些任务到CPU执行：
任务执行过程
1.是否达到核心线程数量？没达到，则创建一个工作线程来执行任务。
2.工作队列是否已满，没满，则将提交的任务存储在工作队列中。
3.是否达到线程最大数量，没达到，则创建一个新的工作线程来执行任务。
4.最后，执行拒绝策略来处理这个任务。
三、线程池API
1.接口定义和实现类
2.方法定义
ExcutorService
//检测ExcutorService 是否已经关闭，直到所有任务完成执行，或超时发生，或当前线程被中断
awaitTermination(long timeout, TimeUnit unit)
// 执行给定任务的集合，执行完毕，返回执行结果
invokeAll(Collection<? extends Callable<T>> tasks)
//执行给定任务的集合，执行完毕或超时，返回结果，其它任务终止
invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
//执行给定的任务，任意一个执行成功则返回结果，其它任务终止
invokeAny(Collection<? extends Callable<T>> tasks)
//执行给定的任务，任意一个执行成功或超时，则返回结果，其它任务终止
invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)
//如果此线程池已经关闭，则返回true
isShutdown();
//如果关闭后所有任务都完成，则返回true
isTerminated();
//优雅的关闭线程池，之前提交的任务将被执行，但不接受新任务
shutdown();
//尝试停止所有正在执行的任务，停止等待任务的处理，并返回等待任务的列表
shutdownNow();
//提交一个用于执行的Callable返回任务，并返回一个Future,用于获取Callable执行结果
submit(Callable<T> task);
//提交可运行任务以执行，并返回一个Future对象，执行结果为null
submit(Runnable task);
//提交可运行任务以执行，并返回Future，执行结果为传入的result
submit(Runnable task, T result);ScheduledExecutorService
//创建并执行一个一次性任务，过了延迟时间就会被执行
schedule(Callable<V> callable,long delay,TimeUnit unit);
//创建并执行一个一次性任务，过了延迟时间就会被执行
schedule(Runnable command,long delay,TimeUnit unit);
//创建并执行一个周期性任务，过了给定的初始延迟时间，会第一次被执行，执行过程中发生异常，那么任务就停止。
//若一次任务执行时长超过了周期时间，下一次任务会等到该次任务执行结束后，立即执行，这也是它和scheduleWithFixedDelay的重要区别
scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit);
//创建并执行一个周期性任务，过了给定的初始延迟时间，会第一次被执行，执行过程中发生异常，那么任务停止。
//若一次任务执行时长超过了周期时间，下一次任务就会在该次任务执行结束的时间基础上，计算执行延迟。对于超过周期的长时间处理任务的不同处理方式，这是它和scheduleAtFixedRate的重要区别
scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit);3.任务执行过程
线程池中的线程在调度任务的过程中的原理如下图所示：
- 是否达到核心线程数量？没达到，创建一个工作线程来执行任务。
- 工作队列是否已满？没满，则将新提交的任务存储在工作队列里。
- 是否达到线程池最大数量？没达到，则创建一个新的工作线程来执行任务。
- 最后，执行拒绝策略来处理这个任务。
从以下几个案例来体会线程池的原理：
案例一：创建核心线程数量5，最大数量10，无界队列，超出核心线程数量的线程存活时间：5秒， 未指定拒绝策略的线程池
package com.ibicd.chapter1.thread_pool_05;
import java.util.List;
import java.util.concurrent.*;
public class ThreadPoolDemo {
public static void main(String[] args) throws Exception {
new ThreadPoolDemo().threadPoolExecutorTest1();
}
public void testCommon(ThreadPoolExecutor threadPoolExecutor) throws InterruptedException {
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(500L);
System.out.println("当前线程池数量为：" + threadPoolExecutor.getPoolSize());
System.out.println("当前线程池等待的数量为：" + threadPoolExecutor.getQueue().size());
// 等待15秒，查看线程数量和队列数量（理论上，会被超出核心线程数量的线程自动销毁）
Thread.sleep(15000L);
System.out.println("15s后，当前线程池线程数量为：" + threadPoolExecutor.getPoolSize());
System.out.println("15s后，当前线程池等待的数量为：" + threadPoolExecutor.getQueue().size());
}
/**
* 1、线程池信息： 核心线程数量5，最大数量10，无界队列，超出核心线程数量的线程存活时间：5秒， 未指定拒绝策略
*
* @throws InterruptedException
*/
private void threadPoolExecutorTest1() throws InterruptedException {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());
testCommon(threadPoolExecutor);
}
}
//由上图的工作原理图可知，threadPoolExecutorTest1() 中创建了一个核心线程数量为5，最大线程数量为10，无边界队列。
//那么一次性能容纳的线程个数为无限，但最大线程数量为10，达到最大线程数量但线程未超过存活时间，则需要等别的线程执行完任务以后再来执行后续提交的任务。执行结果如下：
任务提交成功：0
任务提交成功：1
开始执行：0
任务提交成功：2
开始执行：1
开始执行：2
任务提交成功：3
开始执行：3
任务提交成功：4
开始执行：4
任务提交成功：5
任务提交成功：6
任务提交成功：7
任务提交成功：8
任务提交成功：9
任务提交成功：10
任务提交成功：11
任务提交成功：12
任务提交成功：13
任务提交成功：14
当前线程池数量为：5
当前线程池等待的数量为：10
执行结束：0
执行结束：1
执行结束：2
执行结束：3
执行结束：4
开始执行：5
开始执行：6
开始执行：7
开始执行：8
开始执行：9
执行结束：6
执行结束：8
执行结束：7
执行结束：5
执行结束：9
开始执行：10
开始执行：11
开始执行：12
开始执行：13
开始执行：14
执行结束：13
执行结束：12
执行结束：10
执行结束：14
执行结束：11
15s后，当前线程池线程数量为：5
15s后，当前线程池等待的数量为：0案例二：创建核心线程数量5，最大数量10，队列大小3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的线程池
ps: 若是需要运行案例二乃至后续的代码，只需要将对应的方法替换为案例一中的threadPoolExecutorTest1() 即可
private void threadPoolExecutorTest2() throws InterruptedException {
// 创建一个 核心线程数量为5，最大数量为10,等待队列最大是3 的线程池，也就是最大容纳13个任务。
// 默认的策略是抛出RejectedExecutionException异常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS, new LinkedBlockingDeque<>(3), new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println("有任务被拒绝执行了");
}
});
/**
* 预计结果：
* 1、 5个任务直接分配线程开始执行
* 2、 3个任务进入等待队列
* 3、 队列不够用，临时加开5个线程来执行任务(5秒没活干就销毁)????加开
* 4、 队列和线程池都满了，剩下2个任务，没资源了，被拒绝执行。
* 5、 任务执行，5秒后，如果无任务可执行，销毁临时创建的5个线程
*/
testCommon(threadPoolExecutor);
}案例三：创建核心线程数量5，最大数量5，无界队列，超出核心线程数量的线程存活时间：5秒的线程池
private void threadPoolExecutorTest3() throws InterruptedException {
// 和Executors.newFixedThreadPool(int nThreads)一样
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());
// 预计结果：线程池线程数量为5，超出数量的任务，其他的进入队列中等待执行
testCommon(threadPoolExecutor);
}案例四： 创建核心线程数量5，最大数量 Integer.MAX_VALUE，DelayedWorkQueue 延时队列，超出核心线程数量的线程存活时间：0秒的线程池
private void threadPoolExecutorTest4() {
// 效果1： 提交后，2秒后开始第一次执行，之后每间隔1秒，固定执行一次(如果发现上次执行还未完毕，则等待完毕，完毕后立刻执行)。
// 也就是说这个代码中是，3秒钟执行一次（计算方式：每次执行三秒，间隔时间1秒，执行结束后马上开始下一次执行，无需等待）
ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
threadPoolExecutor.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(3000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("任务-1 被执行，现在时间：" + System.currentTimeMillis());
}
}, 2000, 1000, TimeUnit.MILLISECONDS);
// 效果2：提交后，2秒后开始第一次执行，之后每间隔1秒，固定执行一次(如果发现上次执行还未完毕，则等待完毕，等上一次执行完毕后再开始计时，等待1秒)。
// 也就是说这个代码钟的效果看到的是：4秒执行一次。 （计算方式：每次执行3秒，间隔时间1秒，执行完以后再等待1秒，所以是 3+1）
threadPoolExecutor.scheduleWithFixedDelay(() -> {
try {
Thread.sleep(3000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("任务-2 被执行，现在时间：" + System.currentTimeMillis());
}, 2000, 1000, TimeUnit.MILLISECONDS);
}4.Excutors 工具类（创建线程）
如果需要实例化一个线程池，可以使用 ThreadPoolExecutor，或者ScheduledThreadPoolExecutor创建线程池，也可以使用 Executors 创建线程池。此处介绍Executors 中几个常见的方法：
//常见一个固定大小，任务队列容量无界的线程池，核心线程数=最大线程数
newFixedThreadPool(int nThreads);
//创建的是一个大小无界的缓冲线程池，它的任务队列是一个同步队列。任务加到线程池中，如果池中有空闲线程，则用空闲线程执行，若无则创建新线程执行
//池中的线程空闲超过60s,将被销毁释放。线程数随任务的多少变化，使用于执行耗时较小的异步任务，池的核心线程数=0，最大线程数=Integer.MAX_VALUE.
newCachedThreadPool();
//创建只有一个线程来执行无界任务队列的单一线程池，该线程池确保任务按加入的顺序依次执行。当唯一的线程因异常中止时，将创建一个新的线程来继续执行后续的任务。
//与newFixedThreadPool(1)的区别在于，单一线程的池大小在newSingleThreadExecutor方法中硬编码，不能再改变。
newSingleThreadExecutor() ;
//能定时执行任务的线程池，该池的核心线程数由参数指定，最大线程数=Integer.MAX_VALUE
newScheduledThreadPool(int corePoolSize);四、如何确定线程数量
计算型任务： CPU数量的1-2倍
IO型任务： 根据具体的IO阻塞时长进行考量决定，如tomcat中默认最大线程数：200，也可以考虑根据需要再一个最小数和最大数间自动增减线程数。
