Java线程池核心参数原理及使用指南

// 主要接口和类
executor          // 执行器接口
executorservice   // 执行服务接口
threadpoolexecutor // 线程池核心实现类
scheduledthreadpoolexecutor // 支持定时调度的线程池
executors         // 线程池工厂类

public threadpoolexecutor(
    int corepoolsize,
    int maximumpoolsize,
    long keepalivetime,
    timeunit unit,
    blockingqueue<runnable> workqueue,
    threadfactory threadfactory,
    rejectedexecutionhandler handler
)

// 自定义线程工厂示例
threadfactory customthreadfactory = new threadfactory() {
    private final atomicinteger threadnumber = new atomicinteger(1);
    @override
    public thread newthread(runnable r) {
        thread thread = new thread(r);
        thread.setname("mythread-" + threadnumber.getandincrement());
        thread.setdaemon(false);
        thread.setpriority(thread.norm_priority);
        return thread;
    }
};

// 线程池工作流程伪代码
public void execute(runnable task) {
    if (当前线程数 < corepoolsize) {
        创建新线程执行任务;
    } else if (工作队列未满) {
        将任务加入工作队列;
    } else if (当前线程数 < maximumpoolsize) {
        创建新线程执行任务;
    } else {
        执行拒绝策略;
    }
}

任务提交
    ↓
当前线程数 < corepoolsize? → 是 → 创建核心线程执行
    ↓否
工作队列未满? → 是 → 任务入队等待
    ↓否
当前线程数 < maximumpoolsize? → 是 → 创建非核心线程执行
    ↓否
执行拒绝策略

// 1. 固定大小线程池
executorservice fixedthreadpool = executors.newfixedthreadpool(10);
// 特点：核心线程数=最大线程数，使用无界队列
// 2. 单线程线程池
executorservice singlethreadpool = executors.newsinglethreadexecutor();
// 特点：只有一个线程，任务顺序执行
// 3. 缓存线程池
executorservice cachedthreadpool = executors.newcachedthreadpool();
// 特点：核心线程数为0，最大线程数为integer.max_value，使用同步队列
// 4. 定时任务线程池
scheduledexecutorservice scheduledthreadpool = executors.newscheduledthreadpool(5);
// 支持定时和周期性任务

threadpoolexecutor executor = new threadpoolexecutor(
    5,                                      // corepoolsize
    10,                                     // maximumpoolsize
    60l,                                    // keepalivetime
    timeunit.seconds,                       // unit
    new arrayblockingqueue<>(100),          // workqueue
    executors.defaultthreadfactory(),       // threadfactory
    new threadpoolexecutor.abortpolicy()    // handler
);

public class threadpoolexample {
    public static void main(string[] args) {
        // 创建线程池
        threadpoolexecutor executor = new threadpoolexecutor(
            2, 5, 60, timeunit.seconds,
            new arrayblockingqueue<>(10),
            new customthreadfactory(),
            new threadpoolexecutor.callerrunspolicy()
        );
        // 提交任务
        for (int i = 1; i <= 20; i++) {
            final int taskid = i;
            executor.execute(() -> {
                system.out.println(thread.currentthread().getname() + 
                                 " 执行任务 " + taskid);
                try {
                    thread.sleep(1000);
                } catch (interruptedexception e) {
                    thread.currentthread().interrupt();
                }
            });
        }
        // 监控线程池状态
        monitorthreadpool(executor);
        // 优雅关闭
        executor.shutdown();
        try {
            if (!executor.awaittermination(60, timeunit.seconds)) {
                executor.shutdownnow();
            }
        } catch (interruptedexception e) {
            executor.shutdownnow();
            thread.currentthread().interrupt();
        }
    }
    // 自定义线程工厂
    static class customthreadfactory implements threadfactory {
        private final atomicinteger counter = new atomicinteger(1);
        @override
        public thread newthread(runnable r) {
            thread thread = new thread(r);
            thread.setname("customthread-" + counter.getandincrement());
            thread.setdaemon(false);
            thread.setpriority(thread.norm_priority);
            return thread;
        }
    }
    // 监控线程池状态
    private static void monitorthreadpool(threadpoolexecutor executor) {
        new thread(() -> {
            while (!executor.isterminated()) {
                system.out.println("=== 线程池状态监控 ===");
                system.out.println("核心线程数: " + executor.getcorepoolsize());
                system.out.println("当前线程数: " + executor.getpoolsize());
                system.out.println("活跃线程数: " + executor.getactivecount());
                system.out.println("队列大小: " + executor.getqueue().size());
                system.out.println("完成任务数: " + executor.getcompletedtaskcount());
                system.out.println("总任务数: " + executor.gettaskcount());
                system.out.println("========================\n");
                try {
                    thread.sleep(3000);
                } catch (interruptedexception e) {
                    thread.currentthread().interrupt();
                    break;
                }
            }
        }).start();
    }
}

// 线程数 ≈ cpu核心数 + 1
int corepoolsize = runtime.getruntime().availableprocessors() + 1;

// 线程数 ≈ cpu核心数 * 2
// 或根据具体io等待时间调整
int corepoolsize = runtime.getruntime().availableprocessors() * 2;

// java 1.7+ 支持动态调整参数
executor.setcorepoolsize(10);
executor.setmaximumpoolsize(20);
executor.setkeepalivetime(120, timeunit.seconds);