Java线程池：管理并发任务的最佳方式

概述

线程池是管理线程的池化技术，它避免了频繁创建和销毁线程的开销，提高了程序的性能和响应速度。

1. ThreadPoolExecutor参数

import java.util.concurrent.*;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            5, 10, 60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(100),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );

        for (int i = 0; i < 20; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("任务" + taskId + "执行中");
                try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
            });
        }

        executor.shutdown();
    }
}

2. 线程池执行流程

// 1. 核心线程数未满 -> 创建核心线程执行
// 2. 核心线程数已满 -> 放入任务队列
// 3. 任务队列已满 -> 创建非核心线程执行
// 4. 非核心线程数已满 -> 执行拒绝策略

3. Executors工厂方法

import java.util.concurrent.*;

public class ExecutorsDemo {
    public static void main(String[] args) {
        ExecutorService fixedPool = Executors.newFixedThreadPool(5);
        ExecutorService cachedPool = Executors.newCachedThreadPool();
        ExecutorService singlePool = Executors.newSingleThreadExecutor();
        ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(5);

        scheduledPool.scheduleAtFixedRate(() -> {
            System.out.println("定时任务执行");
        }, 0, 1, TimeUnit.SECONDS);

        fixedPool.shutdown();
        cachedPool.shutdown();
        singlePool.shutdown();
        scheduledPool.shutdown();
    }
}

4. 自定义线程池

@Configuration
public class ThreadPoolConfig {
    @Bean("taskExecutor")
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("task-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

@Service
public class TaskService {
    @Async("taskExecutor")
    public void asyncTask(int taskId) {
        System.out.println("任务" + taskId + "执行中");
    }
}

5. 线程池监控

import java.util.concurrent.ThreadPoolExecutor;

public class ThreadPoolMonitor {
    public static void monitor(ThreadPoolExecutor executor) {
        System.out.println("活跃线程数: " + executor.getActiveCount());
        System.out.println("最大线程数: " + executor.getMaximumPoolSize());
        System.out.println("完成任务数: " + executor.getCompletedTaskCount());
        System.out.println("任务队列大小: " + executor.getQueue().size());
    }
}

最佳实践

1. 避免使用Executors：直接使用ThreadPoolExecutor
2. 合理配置参数：根据任务特点设置线程数
3. 使用自定义线程池：便于管理和监控
4. 设置拒绝策略：避免任务丢失
5. 监控线程池状态：及时发现问题

总结

线程池是管理并发任务的最佳方式，掌握ThreadPoolExecutor的参数和使用，可以高效地处理并发任务。