目录
1、前言
2、Java实现线程池
2.1、Executors框架
2.2、newFixedThreadPool
2.3、newCachedThreadPool
2.4、newSingleThreadExecutor
2.5、newScheduledThreadPool
2.5.1、scheduleAtFixedRate
2.5.2、scheduleWithFixedDelay
2.5.3、异常中断
3、execute()和submit()
4、线程池关闭
5、小结
1、前言
我们继续前面的《【JUC基础】12.线程池（一）》。
2、Java实现线程池
2.1、Executors框架
Executors类是Java并发工具包（java.util.concurrent）中提供的一个工具类，用于创建和管理线程池。它提供了一些静态方法，用于创建不同类型的线程池，简化了线程池的创建和配置过程。
Executor框架提供了各种类型的线程池，主要方法有：
/**
* 固定线程大小的线程池
*/
public static ExecutorService newFixedThreadPool(int nThreads)
/**
* 单线程的线程池
*/
public static ExecutorService newSingleThreadExecutor()
/**
* 可根据实际情况调整线程数量的线程池
*/
public static ExecutorService newCachedThreadPool()
/**
* 单线程的线程池，扩展了延时和周期性执行的功能
*/
public static ExecutorService newSingleThreadScheduledExecutor()
/**
* 可执行线程数量的线程池，扩展了延时和周期性执行的功能
*/
public static ExecutorService newScheduledThreadPool(int corePoolSize)2.2、newFixedThreadPool
newFixedThreadPool()方法。返回一个固定线程数量的线程池。线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲数量，则立即执行。如果没有，则新的任务会被暂存在一个队列中，等到有空闲的线程时，再从任务队列中取出任务执行。
示例代码：
public class FixedThreadPoolTest {
public static void main(String[] args) {
// 固定线程数量为3
ExecutorService executorService = Executors.newFixedThreadPool(3);
for (int i = 0; i < 6; i++) {
executorService.submit(() -> {
System.out.println("Thread Id:" + Thread.currentThread().getId());
ThreadUtil.sleep(1000);
});
}
}
}执行结果如下：我们创建了固定3个线程的线程池，然后我们依次提交6个任务，线程池就会安排这6个任务，然后执行。执行期间我们发现前3个任务和后3个任务的执行时间相差1s，且前3和后3个任务的线程ID是一致的，这就说明线程被分成了2批执行。
2.3、newCachedThreadPool
newCachedThreadPool()方法。返回一个可根据实际情况调整线程数量的线程池。线程池的数量不确定，但如果有空闲线程可以复用，则优先使用可复用线程。如果所有线程都在运行，又有新的任务提交，则会创建新的线程处理任务，处理结束后，线程池回收多余线程。
我们拿2.2示例代码来改造：
public static void main(String[] args) {
// 可调整大小线程池
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
executorService.submit(() -> {
System.out.println("Thread Id:" + Thread.currentThread().getId() + " is running...");
ThreadUtil.sleep(1000);
System.out.println("Thread Id:" + Thread.currentThread().getId() + " done!");
});
// 这里多睡2秒，验证是否复用了空闲线程
if(i == 1){
ThreadUtil.sleep(2000);
}
}
}运行结果：
当我们i==1的时候睡了2秒。2秒过后，ID为9和10的线程已经执行结束。所以当第二批开始执行的时候，我们看到线程9和10被复用执行了，而与fixedThreadPool不同的是，他自动调整了线程池的线程数量大小，而非固定。因此我们看到了11、12、13......后的线程被创建。
2.4、newSingleThreadExecutor
newSingleThreadExecutor()。返回一个只有一个线程的线程池。若多于1个任务提交到线程池，任务会被存在任务等待队列中，直到当前线程空闲后，再取出执行。
示例代码：
public static void main(String[] args) {
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
executorService.submit(() -> {
System.out.println("Thread Id:" + Thread.currentThread().getId() + " is running...");
ThreadUtil.sleep(1000);
System.out.println("Thread Id:" + Thread.currentThread().getId() + " done!");
});
}
}执行结果：
2.5、newScheduledThreadPool
newScheduledThreadPool()。可以根据时间需要对线程进行调度的线程池。主要有两个方法：
/**
* 创建并执行在给定的初始延迟之后，随后以给定的时间段首先启用的周期性动作; 那就是执行将在initialDelay之后开始，然后是initialDelay+period
* ，然后是initialDelay + 2 * period ，等等。
*/
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);
/**
* 创建并执行在给定的初始延迟之后首先启用的定期动作，随后在一个执行的终止和下一个执行的开始之间给定的延迟。
*/
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit);与其他线程池不同，该线程池不一定会立即安排任务执行。更多是起到了定时计划的作用。
2.5.1、scheduleAtFixedRate
使用scheduleAtFixedRate()来调度一个任务。这个任务执行1秒，调度周期是2秒。那么这个任务就会每2秒执行一次。
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
scheduledExecutorService.scheduleAtFixedRate(() -> {
System.out.println(DateUtil.now() + "：Thread Id:" + Thread.currentThread().getId() + " is running...");
ThreadUtil.sleep(1000);
// 参数值0表示：立即执行，不延迟
// 参数值2表示：计划周期为2秒
}, 0, 2, TimeUnit.SECONDS);
}执行结果：
当然，scheduleAtFixedRate是不会允许任务堆叠的情况。当一个任务执行时间大于周期时间时，那么周期计划就会等待任务结束。
举个例子：
如周期为2秒，一个任务执行了1秒。那么该计划周期为2秒；
如周期为2秒，一个任务执行了5秒。那么该计划周期会等待任务5秒执行结束，周期就变为5秒；
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
scheduledExecutorService.scheduleAtFixedRate(() -> {
System.out.println(DateUtil.now() + "：Thread Id:" + Thread.currentThread().getId() + " is running...");
// 这里任务执行改为5秒
ThreadUtil.sleep(5000);
}, 0, 2, TimeUnit.SECONDS);
}执行结果：
2.5.2、scheduleWithFixedDelay
使用scheduleWithFixedDelay()来调度一个任务。这个任务执行1秒，调度周期是2秒。那么这个任务就会每（2+1）秒执行一次。
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
scheduledExecutorService.scheduleWithFixedDelay(() -> {
System.out.println(DateUtil.now() + "：Thread Id:" + Thread.currentThread().getId() + " is running...");
ThreadUtil.sleep(1000);
}, 0, 2, TimeUnit.SECONDS);
}执行结果：
同样，scheduleWithFixedDelay是不会允许任务堆叠的情况。当一个任务执行时间大于周期时间时，那么周期计划就会等待任务结束。
举个例子：
如周期为2秒，一个任务执行了1秒。那么该计划周期为（2+1）秒；
如周期为2秒，一个任务执行了5秒。那么该计划周期会等待任务5秒执行结束，周期就变为（5+2）秒；
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
scheduledExecutorService.scheduleWithFixedDelay(() -> {
System.out.println(DateUtil.now() + "：Thread Id:" + Thread.currentThread().getId() + " is running...");
ThreadUtil.sleep(5000);
}, 0, 2, TimeUnit.SECONDS);
}执行结果：
2.5.3、异常中断
需要注意的是，如果任务本身抛出异常，那么后续的所有任务都会被中断。
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
AtomicInteger i = new AtomicInteger(0);
scheduledExecutorService.scheduleWithFixedDelay(() -> {
System.out.println(DateUtil.now() + "：Thread Id:" + Thread.currentThread().getId() + " is running...");
if(i.get() == 3){
// 这里抛个异常
try {
int number = 10 / 0;
} catch (Exception e) {
e.printStackTrace();
throw e;
}
}
i.getAndIncrement();
ThreadUtil.sleep(1000);
}, 0, 2, TimeUnit.SECONDS);
}可以看到后续都不会继续执行：
3、execute()和submit()
ThreadPoolExecutor提供了两种提交任务的方法：submit和execute。
execute：将任务提交给线程池进行执行，但无法获取任务的执行结果。适用于不关心任务执行结果的场景。例如，执行一些简单的异步操作或无需返回结果的任务。
ExecutorService executor = Executors.newFixedThreadPool(5);
executor.execute(() -> {
// 执行任务的代码
});
submit：将任务提交给线程池进行执行，并返回一个Future对象，通过该对象可以获取任务的执行状态和结果。适用于需要获取任务执行结果或对任务进行异常处理的场景。
ExecutorService executor = Executors.newFixedThreadPool(5);
Future<String> future = executor.submit(() -> {
// 执行任务的代码
return "Task Result";
});
try {
String result = future.get(); // 获取任务执行结果
System.out.println("Task Result: " + result);
} catch (InterruptedException | ExecutionException e) {
// 处理异常
}
4、线程池关闭
前面我们讲了如何创建线程池，线程池类型，以及如何提交任务到线程池中执行。那么当线程池执行完任务，线程处于空闲状态，依旧会占用系统资源。此时我们就需要讲线程池进行关闭，以待垃圾回收器回收。
关闭线程池通常有两种方式：
- shutdown()方法：调用此方法后，线程池会停止接收新的任务，并尝试将已提交的任务执行完成。已提交但未执行的任务会继续执行，而不会被丢弃。
- shutdownNow()方法：调用此方法后，线程池会尝试停止所有正在执行的任务，并丢弃所有未执行的任务。该方法会通过中断（interrupt）线程来终止任务的执行。
较为优雅的方式：
此外还可以使用awaitTermination(timeout, unit)方法等待线程池中的任务执行完成。该方法会阻塞当前线程，直到线程池中的任务全部完成或超过指定的超时时间。如果等待超时，调用shutdownNow()方法中断执行中的任务，并尝试终止线程池。最后，调用isTerminated()方法判断线程池是否已经终止，确认所有任务都已完成。
ExecutorService executor = Executors.newFixedThreadPool(5);
// 关闭线程池
executor.shutdown();
try {
// 等待线程池中的任务执行完成，最多等待5秒
if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
// 等待超时，调用shutdownNow()方法终止执行中的任务
executor.shutdownNow();
// 再次等待线程池中的任务执行完成，最多等待5秒
if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
// 等待超时后仍有任务未完成，可能需要其他处理方式
}
}
} catch (InterruptedException e) {
// 捕获中断异常，可能需要其他处理方式
} finally {
// 判断线程池是否已终止
if (executor.isTerminated()) {
// 线程池已终止，进行相关资源的释放
}
}
通过以上步骤，可以保证线程池能够优雅地终止，并确保所有任务都得到执行或被中断。这样可以避免应用程序中出现线程池资源泄漏或未处理的任务。
5、小结
到此为止，线程池相关的基本知识都介绍完了。当然这些只是线程池的一些基本用法以及常规使用。面对基础入门也是足够了。至于类似线程池的源码，自定义扩展线程池等，放到后面看看进阶篇再写吧~
