executor.submit 主线程把RequestContexts作为参数传给子线程

然后，定义一个自定义的TaskDecorator类，用于在子线程中设置RequestContext：

import java.util.concurrent.Executor;

public class CustomTaskDecorator implements Executor {
    @Override
    public void execute(Runnable runnable) {
        // 获取主线程中的 RequestContext
        RequestContext requestContext = RequestContextHolder.getRequestContext();
        // 在子线程中执行任务
        new Thread(() -> {
            try {
                // 将主线程的 RequestContext 设置到子线程中
                RequestContextHolder.setRequestContext(requestContext);
                runnable.run();
            } finally {
                // 线程结束，清空 RequestContext，否则可能造成内存泄漏
                RequestContextHolder.clearRequestContext();
            }
        }).start();
    }
}

要确定 ThreadPoolExecutor 的最优参数设置，需要考虑多个因素，例如任务的性质（CPU 密集型还是 I/O 密集型）、系统的资源（CPU 核心数、内存等）、任务的到达率和并发量等。以下是一个综合考虑了一些常见情况的示例，您可以根据实际情况进行调整：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class OptimalThreadPoolExecutorExample {

    public static void main(String[] args) {
        int availableProcessors = Runtime.getRuntime().availableProcessors();

        // 对于 CPU 密集型任务
        ThreadPoolExecutor cpuIntensiveExecutor = new ThreadPoolExecutor(
                availableProcessors,  // 核心线程数等于 CPU 核心数
                availableProcessors,  // 最大线程数等于 CPU 核心数
                60,  // 线程空闲 60 秒后销毁
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1000)  // 有足够大的任务队列来缓冲任务
        );

        // 对于 I/O 密集型任务
        ThreadPoolExecutor ioIntensiveExecutor = new ThreadPoolExecutor(
                Math.max(2, availableProcessors / 2),  // 核心线程数通常为 CPU 核心数的一半或更多
                availableProcessors * 2,  // 最大线程数可以设置为 CPU 核心数的两倍
                60,  // 线程空闲 60 秒后销毁
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(10000)  // 较大的任务队列来缓冲 I/O 等待期间的任务
        );

        // 模拟提交任务
        for (int i = 1; i <= 100; i++) {
            // 假设偶数任务为 CPU 密集型，奇数任务为 I/O 密集型
            if (i % 2 == 0) {
                cpuIntensiveExecutor.execute(new CpuIntensiveTask(i));
            } else {
                ioIntensiveExecutor.execute(new IoIntensiveTask(i));
            }
        }

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

    static class CpuIntensiveTask implements Runnable {
        private int taskId;

        public CpuIntensiveTask(int taskId) {
            this.taskId = taskId;
        }

        @Override
        public void run() {
            System.out.println("正在执行 CPU 密集型任务 " + taskId + "，当前线程：" + Thread.currentThread().getName());
            // 模拟 CPU 密集型计算
            long sum = 0;
            for (int i = 0; i < 100000000; i++) {
                sum += i;
            }
        }
    }

    static class IoIntensiveTask implements Runnable {
        private int taskId;

        public IoIntensiveTask(int taskId) {
            this.taskId = taskId;
        }

        @Override
        public void run() {
            System.out.println("正在执行 I/O 密集型任务 " + taskId + "，当前线程：" + Thread.currentThread().getName());
            // 模拟 I/O 操作（例如网络请求或文件读写）
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

请注意，这只是一个示例，实际的最优参数设置需要通过性能测试和监控来确定，根据具体的应用场景和性能要求进行调整。