池化思想：线程池、字符串常量池、数据库连接池
提高资源的利用率
下面是手动创建线程和执行任务过程，可见挺麻烦的，而且线程利用率不高。
- 手动创建线程对象
- 执行任务
- 执行完毕，释放线程对象
线程池的优点：
- 提高线程的利用率
- 提高程序的响应速度
- 便于统一管理线程对象
- 可以控制最大并发数
package chapter09;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.*;
public class Java05_Thread_Pool {
public static void main(String[] args) {
// TODO 线程 - 线程池
// 所谓线程池，其实就是线程对象的容器
// 可以根据需要，在启动时，创建一个或多个线程对象
// 快速创建线程池的4种比较常见的方法
// 它们都是对 ThreadPoolExecutor 的封装，那必然无法满足更复杂，更需要自定义功能的需求场景
// 1. 创建固定数量的线程对象
// ExecutorService是线程服务对象
ExecutorService executorService = Executors.newFixedThreadPool(3);
// 2. 根据需求动态创建线程, 创建的线程可以重复使用，只是当目前线程不够了他会动态增加线程
executorService = Executors.newCachedThreadPool();
// 3. 单一线程
executorService = Executors.newSingleThreadExecutor();
// 4. 定时调度线程, 线程有3个，但是线程在什么时候执行我们可以去定义他
executorService = Executors.newScheduledThreadPool(3);
// 使用submit提交任务
for (int i = 0; i < 5; i++) {
executorService.submit(new Runnable() {
@Override
public void run() {
System.out.println("submit方式 " + Thread.currentThread().getName());
}
});
}
// 使用execute提交任务
for (int i = 0; i < 5; i++) {
executorService.execute(new Runnable() {
@Override
public void run() {
System.out.println("execute方式 " + Thread.currentThread().getName());
}
});
}
executorService.shutdown(); // 关闭线程池
// 如果你需要更多的控制和自定义选项，使用 ThreadPoolExecutor 可以满足更复杂的需求
// 使用银行柜台服务的场景来解释 ThreadPoolExecutor 的每个参数
ExecutorService executorService1 = new ThreadPoolExecutor(
3, // corePoolSize-核心线程数，即银行的初始柜台数，
// 具体来说：银行一开始有 3 个柜台，每个柜台有一个员工（线程）在处理客户（任务）。这些柜台是常驻的，即使没有客户时也不会关闭
5, // maximumPoolSize-最大线程数，即银行在高峰期能开设的最大柜台数量
// 在客户数量增加的时候，银行可以最多开设 5 个柜台来处理客户。超过这个数量的客户需要排队等候
1L, // keepAliveTime-非核心线程的存活时间
// 如果一个临时增加的柜台（超过核心柜台数的部分）空闲了 1 秒钟，那么这个柜台就会关闭（线程会被回收）。
// 这就像银行在高峰期增加了柜台，但在高峰期过后，临时柜台会在短时间内关闭，以节省资源
TimeUnit.SECONDS, // keepAliveTime's unit-存活时间的单位
// 这里的单位是秒，表示非核心线程在空闲 1 秒后会被关闭，跟上面的 keepAliveTime 配合使用
new ArrayBlockingQueue<>(3), // workQueue-等待队列，用于存放等待处理的任务
// 假如银行有一个容量为 3 的等候区（队列），当所有柜台都在忙碌时，新的客户会在这个等候区等待。
// 如果等候区也满了，那么将会触发下面handler的策略（下面是 拒绝策略）
Executors.defaultThreadFactory(), // threadFactory-线程工厂，用于创建新线程
// 这是一个工厂模式，负责为银行创建新的柜台（线程）。
// Executors.defaultThreadFactory() 是默认的实现，它会创建一个新的线程来处理任务。
new ThreadPoolExecutor.AbortPolicy() // handler-当线程池和等待队列都满了时如何处理新任务的策略
// 如果所有的柜台（线程）和等候区（队列）都满了，再来新的客户时会执行拒绝策略。
// AbortPolicy 会抛出 RejectedExecutionException，就像银行告诉新来的客户“我们现在无法处理您的请求，请稍后再试”。
);
/*
ExecutorService类对象可以使用两种方法向线程池提交任务：submit 和 execute。
execute 方法用于提交不需要返回结果的任务。它是 Executor 接口中的方法
返回类型: void。execute 方法不返回任何结果。
异常处理: 如果任务在执行过程中抛出未经检查的异常，该异常将直接传播到调用者所在的线程。
适用场景: 适用于不需要返回结果的任务，比如简单的异步执行任务。
submit 方法用于提交有返回结果的任务。它是 ExecutorService 接口中的方法。
返回类型: Future<V>。submit 方法返回一个 Future 对象，可以通过该对象获取任务的执行结果或取消任务。
异常处理: 如果任务在执行过程中抛出未经检查的异常，该异常将被捕获，并存储在返回的 Future 对象中。调用 Future.get() 方法时，会抛出 ExecutionException。
适用场景: 适用于需要返回结果的任务，比如计算任务，或者你需要检查任务是否成功完成。
通过这两种方法，你可以根据任务的具体需求来选择合适的提交方式。
如果任务需要返回结果或需要检查执行状态，使用 submit；
如果任务只是执行，不需要返回结果，使用 execute。
*/
List<Future<Integer>> futureList = new ArrayList<>();
// 使用submit提交任务，并且改变需要执行的Runnable任务来看看线程池有什么变化情况
// 任务数i在6个以内，executorService1指向的线程池只开3个线程
// 7个任务开四个线程, 8个任务开五个线程
// 9个任务直接 Exception in thread "main" java.util.concurrent.RejectedExecutionException
// 解释:
// 3个任务：直接全部给到三个核心线程处理
// 4~6个任务：三个核心线程处理其中3个任务，剩下的任务进入等待队列
// 7个任务：三个核心线程处理其中3个任务，等待队列存放3个任务，那还剩下1个任务就交给非核心线程处理（增设了一个额外的线程）
// 8个任务：三个核心线程处理其中3个任务，等待队列存放3个任务，那还剩下2个任务就交给两个非核心线程处理（增设了两个额外的线程）
// 9个任务：三个核心线程处理其中3个任务，等待队列存放3个任务，那还剩下3个任务，但是最大线程数是5个，
// 也就是说再多只能在三个核心线程的基础上再增设两个额外的线程，但是也不够处理剩下的3个任务
// 或者说 最大线程数大小 5 + 等待队列大小 3 = 8 < 任务所需的线程数 9
for (int i = 1; i <= 3; i++) {
int taskId = i;
Future<Integer> future = executorService1.submit(new Callable() {
@Override
public Integer call() {
System.out.println(Thread.currentThread().getName() + "正在处理业务" + taskId);
return taskId;
}
});
futureList.add(future);
}
Iterator<Future<Integer>> it = futureList.iterator();
while (it.hasNext()) {
Future<Integer> future = it.next();
try {
Integer result = future.get();
System.out.println("Result: " + result);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (ExecutionException e) {
throw new RuntimeException(e);
}
}
// 使用execute方式提交任务
for (int i = 1; i <= 9; i++) {
int taskId = i;
executorService1.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "正在处理业务" + taskId);
}
});
}
}
}