实现线程池用Java那个类来实现？可以创建几种？

在Java中，我们可以使用多种类来实现线程池。本文将介绍常用的几种线程池类及其特点。

1. ThreadPoolExecutor

ThreadPoolExecutor是Java标准库提供的一个线程池实现类。它提供了丰富的配置参数，如核心线程数、最大线程数、空闲线程存活时间等。通过构造函数或者setCorePoolSize()、setMaximumPoolSize()、setKeepAliveTime()等方法，可以灵活地控制线程池的行为。

import java.util.concurrent.*;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        int corePoolSize = 2; // 核心线程数
        int maximumPoolSize = 4; // 最大线程数
        long keepAliveTime = 60L; // 空闲线程存活时间(秒)
        TimeUnit unit = TimeUnit.SECONDS; // 时间单位
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(10); // 任务队列
        ThreadFactory threadFactory = Executors.defaultThreadFactory(); // 线程工厂
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy(); // 拒绝策略

        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);

        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            threadPool.execute(() -> {
                System.out.println("Task " + taskId + " is running by " + Thread.currentThread().getName());
            });
        }
    }
}

2. ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor是一个定时执行任务的线程池实现类。它继承自ThreadPoolExecutor,并提供了一个schedule()方法，用于定时执行任务。通过设置任务的执行间隔和重复次数，可以实现周期性任务。

import java.util.concurrent.*;
import java.time.Duration;
import java.util.Timer;
import java.util.TimerTask;

public class ScheduledThreadPoolDemo {
    public static void main(String[] args) {
        ScheduledThreadPoolExecutor scheduledThreadPool = new ScheduledThreadPoolExecutor(2); // 定时执行任务的线程池大小为2
        Timer timer = new Timer(); // 定时器对象
        TimerTask task = new MyTimerTask(); // 自定义定时任务类
        timer.scheduleAtFixedRate(task, 0, Duration.ofSeconds(5)); // 每隔5秒执行一次任务
    }
}

3. ForkJoinPool

ForkJoinPool是一个适用于计算密集型任务的线程池实现类。它使用了分治算法和归约技术，可以在多核CPU上充分利用资源，提高程序的执行效率。与ThreadPoolExecutor不同，ForkJoinPool中的任务是不可中断的，因此需要使用submit()方法提交任务，并等待任务完成。当任务无法拆分成更小的子任务时，可以使用invoke()方法提交一个计算密集型任务。

import java.util.concurrent.*;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class ForkJoinPoolDemo {
    public static void main(String[] args) throws Exception {
        ForkJoinPool forkJoinPool = new ForkJoinPool(); // ForkJoinPool实例化对象
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // 需要处理的任务列表
        List<Integer> result = forkJoinPool.invoke(() -> Arrays.stream(numbers).parallel().collect(Collectors.toList())); // 并行处理任务列表并返回结果列表
        System.out.println("Result: " + result); // 输出结果列表
    }
}