首页 > 编程笔记 > Java笔记 阅读：78

Java常见线程池及其应用场景（6种，附带实例）

在并发编程的实践中，线程池是一种资源管理工具，用于有效地管理线程资源。如果遇到需要使用线程池的场景，应该先思考这种场景需要使用什么样的线程池，从而避免线程资源滥用。这种选择可能比较困难，不过不用担心，Java 其实早就已经给我们提供了快速创建线程池的方法，并且不需要设置烦琐的参数，“开箱即用”。

以下是 Java 中几种常见类型的线程池及其各自的适用场景。

Java FixedThreadPool线程池

这是一个容量固定的线程池，它可以一次性预先创建线程，并且重用其中的线程。

该类型线程池的适用场景如下：
使用示例代码如下： 
ExecutorService executorService = Executors.newFixedThreadPool(10);
executorService.execute(new Runnable() {
    public void run() {
           // 任务代码
    }
});
在能预知最大并发线程数时适合使用 FixedThreadPool，这样能避免线程频繁创建和销毁的开销，但是当所有线程都繁忙时，新任务会在队列中等待，可能导致延迟。

Java CachedThreadPool线程池

这是一个会根据需要创建新线程的线程池，但如果线程空闲超过60s，它会被终止并从缓存中移除。

该类型线程池的适用场景如下:
使用示例代码如下： 
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
executorService.execute(new Runnable() {
    public void run() {
        // 任务代码
    }
});
executorService.shutdown();
CachedThreadPool 可以灵活地创建线程满足任务要求，理论上无线程数上限，适用于负载较轻的服务器。但是线程数可能会迅速膨胀，从而耗尽资源，对于长生命周期的任务，不建议使用。

Java SingleThreadExecutor线程池

这是一个单线程的线程池，它创建单个工作线程来执行任务。

该类型线程池的适用场景如下：
使用示例代码如下： 
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
executorService.execute(new Runnable() {
    public void run() {
        // 任务代码
    }
});
executorService.shutdown();
SingleThreadExecutor 保证所有任务按照提交顺序执行，但是如果唯一的线程因异常终止，则会影响后续任务执行，因为它不适用于大量任务并发执行的场景。

Java ScheduledThreadPool线程池

这是一个可以安排在给定时间后执行任务或定期执行的线程池。

该类型线程池的适用场景如下：
使用示例代码如下： 
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
executorService.schedule(new Runnable() {
    public void run() {
        // 任务代码
    }
}, 5, TimeUnit.SECONDS);
executorService.shutdown();
ScheduledThreadPool 支持任务的定时执行和周期性执行，可以调整线程池大小以满足不同程度的并发需求，但是使用不当可能会导致任务堆积或线程资源紧张。

Java WorkStealingPool线程池

这是 Java 8 新增的线程池，基于 Fork/Join 框架，采用工作窃取算法。

该类型线程池适用于存在大量数据被分割成多个小任务并行执行的场景。

使用示例代码如下： 
ExecutorService workStealingPool = Executors.newWorkStealingPool();
executorService.execute(new Runnable() {
    public void run() {
        // 任务代码
   }
});
在使用 WorkStealingPool 时，应确保主线程不会立即退出，因为 WorkStealing-Pool 中的线程执行的是守护线程。它可以优化任务执行时间，提高线程利用率，自动地负载均衡，但不易调试，因为任务窃取是隐蔽进行的，适合计算密集型任务，不适合 I/O 密集型任务。

Java ForkJoinPool线程池

这是专门为大量并发任务设计的并行执行线程池，它实现了 MapReduce 算法。在 Fork/Join 框架中，任何任务都可以被拆分（Fork）成更小的任务执行，然后将结果合并（Join）。

该类型线程池的适用场景如下：
使用示例代码如下： 
import java.util.concurrent.*;
public class ForkJoinExample extends RecursiveTask<Integer> {
    private final int[] numbers;
    private final int start;
    private final int end;
    public ForkJoinExample(int[] numbers, int start, int end) {
        this.numbers = numbers;
        this.start = start;
        this.end = end;
    }
    @Override
    protected Integer compute() {
        int length = end - start;
        if (length <= 2) {
            return computeDirectly();
        }
        ForkJoinExample firstTask = new ForkJoinExample(numbers, start, start + length / 2);
        ForkJoinExample secondTask = new ForkJoinExample(numbers, start + length / 2, end);
        firstTask.fork();
        Integer secondResult = secondTask.compute();
        Integer firstResult = firstTask.join();
        return firstResult + secondResult;
    }
    private Integer computeDirectly() {
        int sum = 0;
        for (int i = start; i < end; i++) {
            sum += numbers[i];
        }
        return sum;
    }
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        ForkJoinTask<Integer> task = new ForkJoinExample(numbers, 0, numbers.length);
        ForkJoinPool pool = new ForkJoinPool();
        Integer result = pool.invoke(task);
        System.out.println("Result is: " + result);
    }
}
ForkJoinPool 适用于大规模并行计算，尤其是复杂的递归算法和大量数据的处理，但是如果任务拆分得不合理，可能会导致性能下降，而且它的实现相对复杂，需要理解递归和分治算法。

在选择线程池的类型时，需要基于应用场景和需求选择。记住，没有一种线程池适用于所有场景。我们应该根据应用程序的工作负载和资源限制来选择合适的线程池。同时，始终记得优雅地关闭线程池，以免造成资源泄漏。

相关文章