通过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