通过ThreadPoolExecutor创建线程池。
ThreadPoolExecutor构造方法参数：
int corePoolSize//核心线程数量int maximumPoolSize//最大线程数long keepAliveTime//当线程数大于核心线程数时，多余空闲线程存活的最长时间TimeUnit unit//keepAliveTime的时间单位BlockingQueue<Runnable> workQueue//任务队列，用来储存等待执行任务的队列ThreadFactory threadFactory//用来创建线程的线程工厂，一般默认RejectedExecutionHandler handler//拒绝策略，当提交的任务过多而不能及时处理时所执行的处理策略
演示使用ThreadPoolExecutor执行任务
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class TestThreadPool {
public static void main(String[] args) {
// 创建一个线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
5, // 核心线程数
5, // 最大线程数
2, // 当线程数大于核心线程数时，多余的空闲线程存活的最长时间
TimeUnit.SECONDS, // 存活时间单位
new LinkedBlockingQueue<>(10) // 任务队列，用来储存等待执行任务的队列
);
// 提交任务给线程池
for (int i = 0; i < 10; i++) {
final int taskId = i;
executor.submit(new Runnable() {
@Override
public void run() {
System.out.println("Task " + taskId + " is being executed by " + Thread.currentThread().getName());
try {
Thread.sleep(1000); // 模拟任务执行时间
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task " + taskId + " is completed");
}
});
}
// 关闭线程池
executor.shutdown();
}
}
在这个示例中，使用 ThreadPoolExecutor 创建了一个线程池，提交了 10 个任务给线程池，线程池会根据核心线程数和任务队列的情况来分配线程执行任务。任务执行完毕后，线程池会复用线程，如果线程池中的线程数量超过核心线程数，空闲线程在空闲时间后可能会被回收。
最后，调用 shutdown 方法关闭线程池，等待所有任务完成后关闭。
代码运行：
上述代码中的，提交任务给线程池时所调用的submit也可更改为execute方法。
execute 适用于只关心任务的执行，不需要获取返回值或处理异常的情况；submit 适用于需要获取任务的执行结果或捕获异常的情况。
ThreadPoolExecutor类：
AbstractExecutorService抽象类（ThreadPoolExecutor的父类）：
线程的处理结果如何获取？
代码：
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
public class TestThreadPool2 {
public static void main(String[] args) {
// 创建一个线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
5, // 核心线程数
5, // 最大线程数
2, // 当线程数大于核心线程数时，多余的空闲线程存活的最长时间
TimeUnit.SECONDS, // 存活时间单位
new LinkedBlockingQueue<>(10) // 任务队列，用来储存等待执行任务的队列
);
List<Future<Integer>> futureList = new ArrayList<>();
// 提交任务给线程池
for (int i = 0; i < 6; i++) {
final int taskId = i;
Future<Integer> future = executor.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println("Task " + taskId + " is being executed by " + Thread.currentThread().getName());
Thread.sleep(2000); // 模拟任务执行时间
return taskId * 2;
}
});
futureList.add(future);
}
System.out.println("———————flag1———————————");
// 获取线程的返回值
for (Future<Integer> future : futureList) {
try {
int result = future.get();//get方法会阻塞，直到任务完成并返回结果
System.out.println("Task result: " + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
System.out.println("———————flag2———————————");
// 关闭线程池
executor.shutdown();
}
}
该示例代码创建了一个自定义的 ThreadPoolExecutor，并提交了一系列的 Callable 任务。每个任务都会返回一个整数值。我们将每个任务的 Future 对象存储在一个列表中，然后使用 get 方法获取每个任务的返回值。注意，get 方法会阻塞，直到任务完成并返回结果。
输出：
参考：
- https://pdai.tech/md/java/thread/java-thread-x-juc-executor-ThreadPoolExecutor.html#threadpoolexecutor%E6%BA%90%E7%A0%81%E8%AF%A6%E8%A7%A3
- https://javaguide.cn/java/concurrent/java-concurrent-questions-03.html#%E7%BA%BF%E7%A8%8B%E6%B1%A0