Java的ThreadPoolExecutor

/**
     * 在这个例子中，我们创建了一个线程池执行器 threadPoolExecutor，然后提交了10个任务给线程池执行。每个任务都打印了当前任务的编号和执行线程的名称，并模拟了一个简单的任务执行过程（通过 Thread.sleep() 方法）。
     * 请注意，我们在最后调用了 threadPoolExecutor.shutdown() 方法来关闭线程池，这是一种优雅地关闭线程池的方式，它会等待所有任务执行完成后再关闭线程池。
     */
    @Test
    public void test() {
        final int KEEP_ALIVE_SECONDS = 60;
        final BlockingQueue<Runnable> poolWorkQueue = new LinkedBlockingQueue<>(200);
        final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                100, 200, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                poolWorkQueue, new ThreadPoolExecutor.CallerRunsPolicy());
        // 提交任务到线程池执行
        for (int i = 0; i < 10; i++) {
            int taskId = i;
            threadPoolExecutor.execute(() -> {
                try {
                    System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                    // 模拟任务执行时间
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        // 关闭线程池
        threadPoolExecutor.shutdown();
    }

案例二

import java.util.*;
import java.util.concurrent.*;

public class Main {
    private static final int KEEP_ALIVE_SECONDS = 60;
    private static final BlockingQueue<Runnable> poolWorkQueue = new LinkedBlockingQueue<>(200);
    private final static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            100, 200, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
            poolWorkQueue, new ThreadPoolExecutor.CallerRunsPolicy());

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 模拟一个包含任务的Map
        Map<Integer, Integer> bindedPackageMap = new HashMap<>();
        for (int i = 1; i <= 10; i++) {
            bindedPackageMap.put(i, i * 10);
        }

        // 异步执行任务
        List<CompletableFuture<Integer>> futureList = new ArrayList<>();
        for (Integer value : bindedPackageMap.values()) {
            CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
                // 模拟耗时操作
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return value * 2; // 任务结果
            }, threadPoolExecutor);
            futureList.add(future);
        }

        // 等待所有任务完成，并获取结果
        List<Integer> resultList = new ArrayList<>();
        for (CompletableFuture<Integer> future : futureList) {
            resultList.add(future.get());
        }

        // 输出结果
        System.out.println("Task results: " + resultList);

        // 关闭线程池
        threadPoolExecutor.shutdown();
    }
}

创建了一个包含了一组任务的 bindedPackageMap，其中键值对的值被用作任务的输入。然后，我们使用 CompletableFuture.supplyAsync() 异步执行了这些任务，每个任务执行一个简单的操作（这里模拟了一个耗时的操作，即休眠 1 秒，并将值乘以 2），并将结果存储在 CompletableFuture 对象中。最后，我们等待所有任务完成，并输出结果。

请注意，我们在最后调用了 threadPoolExecutor.shutdown() 来关闭线程池，以确保程序正常结束并释放资源。
当然如果在springboot的web项目中则需要再次创建线程池后在关闭否则创建一次而关闭后则没有创建新的线程就会无法正常运行程序