概述
- 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
- 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
- 提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控
一、实现原理
1.1、使用
ThreadPoolExecutor executor = new ThreadPoolExecutor(
4, //核心线程数
10,//最大线程数
10,//空闲线程存活时间
TimeUnit.SECONDS,//时间单位
new LinkedBlockingDeque<>()//阻塞队列
);
Runnable runnable=new Runnable() {
@Override
public void run() {
System.out.println("执行一个任务");
}
};
executor.execute(runnable);
创建ThreadPoolExecutor的核心参数
- corePoolSize: 核心线程数
- maximumPoolSize: 最大线程数
- keepAliveTime: 空闲线程存活时间，0表示永久
- TimeUnit：keepAliveTime的时间单位
- BlockingQueue: 任务存放的阻塞队列
除此之外还有线程工程和拒绝策略
- ThreadFactory: 线程工厂，用来定制线程，一般用默认的Executors.defaultThreadFactory()
- RejectedExecutionHandler: 拒绝策略，默认是AbortPolicy，直接抛出异常
1.2、向线程池提交任务
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
//如果线程数小于核心线程数，则创建线程并执行
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
//如果线程数大于核心线程数或者线程创建失败，则把当前任务放到工作队列中
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
//如果线程池不处于运行中或者任务无法放入，并且当前线程数小于
//最大运行的线程数,则创建一个线程去执行
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//抛出RejectedExecutionException异常
else if (!addWorker(command, false))
reject(command);
}
线程池把每个Runnable任务封装成一个Worker，Worker中在执行完了后，还会循环获取阻塞队列里面的任务来执行，Worker的run方法实现如下
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
//ste1:获取队列里面的第一个任务
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
w.lock();
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
//step2：执行任务
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
//step3：从队列里面拿下一个任务
processWorkerExit(w, completedAbruptly);
}
}
当提交一个新任务到线程池时，线程池的处理流程如下
- 判断核心线程池里的线程是否都在执行任务。如果不是，则创建一个新的工作线程来执行任务。如果核心线程池里的线程都在执行任务，则进入下个流程
- 判断工作队列是否已经满。如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程
- 判断线程池的线程是否都处于工作状态。如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给拒绝策略来处理这个任务
1.3、阻塞队列
用于保存等待执行的任务的阻塞队列，可以选择一下几个阻塞队列
- ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按FIFO（先进先出）原则对元素进行排序
- LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列
- SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于Linked-BlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列
- PriorityBlockingQueue：一个具有优先级的无限阻塞队列
1.4、拒绝策略
当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。在JDK 1.5中Java线程池框架提供了以下4种策略
- AbortPolicy：直接抛出异常。
- CallerRunsPolicy：只用调用者所在线程来运行任务
- DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务
- DiscardPolicy：不处理，丢弃掉
当然，也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化存储不能处理的任务
1.5、关闭线程池
可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池。它们的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。但是它们存在一定的区别，shutdownNow首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表，而shutdown只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程。 只要调用了这两个关闭方法中的任意一个，isShutdown方法就会返回true。当所有的任务都已关闭后，才表示线程池关闭成功，这时调用isTerminaed方法会返回true。至于应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定
-
通常调用shutdown方法来关闭线程池，
-
如果任务不一定要执行完，则可以调用shutdownNow方法
1.6、线程池的监控
线程池提供了参数进行监控，在监控线程池的时候可以使用以下属性
- taskCount：线程池需要执行的任务数量。
- completedTaskCount：线程池在运行过程中已完成的任务数量，小于或等于taskCount
- largestPoolSize：线程池里曾经创建过的最大线程数量。通过这个数据可以知道线程池是否曾经满过。如该数值等于线程池的最大大小，则表示线程池曾经满过
- getPoolSize：线程池的线程数量。如果线程池不销毁的话，线程池里的线程不会自动销毁，所以这个大小只增不减
- getActiveCount：获取活动的线程数
通过扩展线程池进行监控。可以通过继承线程池来自定义线程池，重写线程池的beforeExecute、afterExecute和terminated方法，也可以在任务执行前、执行后和线程池关闭前执行一些代码来进行监控。例如，监控任务的平均执行时间、最大执行时间和最小执行时间等。这几个方法在线程池里是空方法
二、Executor
Executors是一个创建线程池的工具类，主要由3部分组成
- 任务：被执行任务需要实现的接口：Runnable接口或者Callable接口
- 任务的执行：包括任务执行机制的核心接口Executor，以及继承自Executor的ExecutorService接口。Executor框架有两个关键类实现了ExecutorService接口（ThreadPoolExecutor和ScheduledThreadPoolExecutor）
- 异步计算的结果：包括Future接口和实现Future接口的FutureTask类
Executor框架包含的主要的类与接口
- Executor是一个接口，它是Executor框架的基础，它将任务的提交与任务的执行分离开来
- ThreadPoolExecutor是线程池的核心实现类，用来执行被提交的任务
- ScheduledThreadPoolExecutor是一个实现类，可以在给定的延迟后运行命令，或者定期执行命令。ScheduledThreadPoolExecutor比Timer更灵活，功能更强大
- Future接口和实现Future接口的FutureTask类，代表异步计算的结果
- Runnable接口和Callable接口的实现类，都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行
ThreadPoolExecutor通常使用工厂类Executors来创建。Executors可以创建3种类型的ThreadPoolExecutor：SingleThreadExecutor、FixedThreadPool和CachedThreadPool
2.1、FixedThreadPool
创建一个指定线程数的线程池，核心线程数量和最大线程数量都为nThreads，永不超时。适用于少量长时间执行的任务
ExecutorService executorService = Executors.newFixedThreadPool(64);
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
2.2、SingleThreadExecutor
创建一个单线程的线程池，核心线程为1，最大线程为1，永不超时。适用于排队执行任务
Executors.newSingleThreadExecutor();
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
2.3、CachedThreadPool
创建一个缓存的线程池，核心线程为0，最大线程为Integet.MAX_VALUE，超时时间是60s。适用于大量段时间执行的任务
Executors.newCachedThreadPool();
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
三、异步任务
3.1、Future
异步任务需要依赖线程池实现，如下实现一个简单的异步任务
private static void test() {
Callable<String> callable = new Callable<String>() {
@Override
public String call() throws Exception {
Thread.sleep(2000);
return "result is success";
}
};
ExecutorService executor = Executors.newCachedThreadPool();
Future<String> future = executor.submit(callable);
try {
String result = future.get();
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
}
}
异步任务的结果为Future，通过Future.get()方法获取异步任务的结果，get()方法是一个阻塞方法，如果抛出了异常或者被取消或者任务被中断，则会抛出相应异常
3.2、CompletableFuture
Future.get()方法会阻塞线程，感觉意义不大，Java还提供了CompletableFuture实现异步任务
ExecutorService executors = Executors.newCachedThreadPool();
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(new Supplier<Integer>() {
@Override
public Integer get() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 100;
}
}, executors);
future.thenAccept(new Consumer<Integer>() {
@Override
public void accept(Integer integer) {
System.out.println("结果：" + integer);
}
});
