Java线程池深度解析与应用实践

最新推荐文章于 2024-08-04 11:22:41 发布

架构师编程旅途

最新推荐文章于 2024-08-04 11:22:41 发布

阅读量788

点赞数 6

分类专栏： java线程池文章标签： java 开发语言

本文链接：https://blog.csdn.net/liuyuan5363/article/details/137395933

版权

java线程池专栏收录该内容

1 篇文章 0 订阅

订阅专栏

在Java多线程编程中，线程池是一个非常重要的概念。它不仅能够有效地管理和复用线程，还能提高系统的性能和响应速度。

线程池的概念

线程池是一种用来管理线程的机制，它创建一定数量的线程，并将这些线程放在一个池中。当有任务到来时，线程池会分配一个线程去执行这个任务，任务执行完毕后，线程不会立即销毁，而是返回线程池中等待下一个任务。这种方式避免了频繁创建和销毁线程带来的性能开销。

Java线程池的实现

在Java中，线程池的实现主要是通过java.util.concurrent.ExecutorService接口及其实现类来完成的。Java提供了几种不同的线程池实现，包括ThreadPoolExecutor、ScheduledThreadPoolExecutor和ForkJoinPool等。

1. `ThreadPoolExecutor`

ThreadPoolExecutor是最常用的线程池实现，它提供了丰富的配置选项，允许开发者根据实际需求定制线程池的行为。ThreadPoolExecutor的核心参数包括：

corePoolSize：核心线程数，即使线程是空闲的，线程池也会保留这么多线程。
maximumPoolSize：最大线程数，线程池中允许的最大线程数。
keepAliveTime：非核心线程的空闲存活时间，当线程数超过核心线程数时，这些线程在终止前等待新任务的最长时间。
workQueue：任务的等待队列，当线程池中的所有线程都在忙时，新任务会进入这个队列等待执行。

2. `ScheduledThreadPoolExecutor`

ScheduledThreadPoolExecutor是另一种线程池，它能够延迟执行或定期执行任务。这个线程池创建了多个工作线程，并且可以调度要在将来某个时间点执行的任务。

3. `ForkJoinPool`

ForkJoinPool是一个用于并行处理任务并合并结果的线程池。它特别适合于那些可以分解为小任务的问题，通过分而治之的方式，可以显著提高性能。

使用示例

//示例1：使用Executors工厂方法创建固定大小的线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小为10的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 20; i++) {
            // 提交任务到线程池执行
            executorService.submit(() -> {
                System.out.println("执行任务：" + Thread.currentThread().getName());
            });
        }

        // 关闭线程池
        executorService.shutdown();
    }
}
//示例2：使用ScheduledThreadPoolExecutor执行定时任务
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个大小为5的定时线程池
        ScheduledThreadPoolExecutor scheduledExecutorService = new ScheduledThreadPoolExecutor(5);

        // 定时任务，每隔1秒执行一次，共执行5次
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("定时任务执行：" + System.currentTimeMillis());
        }, 0, 1, TimeUnit.SECONDS);

        // 5秒后关闭线程池
        scheduledExecutorService.shutdown();
    }
}
//示例3：自定义ThreadPoolExecutor并设置拒绝策略
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class CustomThreadPoolExample {
    public static void main(String[] args) {
        int corePoolSize = 5;
        int maximumPoolSize = 10;
        long keepAliveTime = 60;
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();

        // 自定义拒绝策略：当线程池和队列都满了，会抛出异常
        ThreadPoolExecutor.AbortPolicy abortPolicy = new ThreadPoolExecutor.AbortPolicy() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                throw new RuntimeException("任务提交失败，线程池和队列都已满！");
            }
        };

        // 创建自定义线程池
        ThreadPoolExecutor executorService = new ThreadPoolExecutor(
            corePoolSize,
            maximumPoolSize,
            keepAliveTime,
            unit,
            workQueue,
            abortPolicy
        );

        for (int i = 0; i < 15; i++) {
            executorService.submit(() -> {
                System.out.println("执行任务：" + Thread.currentThread().getName());
            });
        }

        // 关闭线程池
        executorService.shutdown();
    }
}
//示例4：使用ForkJoinPool并行处理任务
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class ForkJoinPoolExample extends RecursiveTask<Integer> {
    private final int threshold = 10;
    private final int[] data;

    public ForkJoinPoolExample(int[] data) {
        this.data = data;
    }

    @Override
    protected Integer compute() {
        int sum = 0;
        if (data.length > threshold) {
            int middle = data.length / 2;
            // 分解任务
            ForkJoinPoolExample left = new ForkJoinPoolExample(Arrays.copyOfRange(data, 0, middle));
            ForkJoinPoolExample right = new ForkJoinPoolExample(Arrays.copyOfRange(data, middle, data.length));
            // 合并结果
            return left.invoke() + right.invoke();
        } else {
            // 计算子任务的和
            for (int num : data) {
                sum += num;
            }
            return sum;
        }
    }

    public static void main(String[] args) {
        int[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        ForkJoinPool pool = new ForkJoinPool();
        int result = pool.invoke(new ForkJoinPoolExample(data));
        System.out.println("结果：" + result);
    }
}

常见的线程池及其区别

不同的线程池在Java中主要通过java.util.concurrent.ExecutorService接口的实现类来区分，每种线程池都有其特定的用途和行为。

1. `ThreadPoolExecutor`

这是最基本且最灵活的线程池实现。它允许开发者自定义线程池的大小、存活时间、工作队列等参数。ThreadPoolExecutor适用于大多数通用的并发任务。

核心线程数（corePoolSize）：即使线程是空闲的，线程池也会保留这么多线程。
最大线程数（maximumPoolSize）：线程池中允许的最大线程数。
存活时间（keepAliveTime）：非核心线程的空闲存活时间，当线程数超过核心线程数时，这些线程在终止前等待新任务的最长时间。
工作队列（workQueue）：任务的等待队列，当线程池中的所有线程都在忙时，新任务会进入这个队列等待执行。
拒绝策略（handler）：当工作队列和线程池都满了，新任务如何处理的策略。

2. `ScheduledThreadPoolExecutor`

这个线程池可以执行定时任务或者周期性任务。它继承自ThreadPoolExecutor，因此也拥有ThreadPoolExecutor的所有特性，但是它专门用于调度任务。

定时任务：可以延迟执行任务或者按照固定的时间间隔重复执行任务。
线程数：创建时需要指定线程数，这个线程池会创建固定数量的线程。

3. `ForkJoinPool`

这是一个用于并行处理任务并合并结果的线程池，特别适合于那些可以分解为小任务的问题。ForkJoinPool使用工作窃取算法来提高任务执行的效率。

并行处理：适用于可以分解为多个小任务并行执行的问题。
工作窃取算法：当一个线程完成自己的任务后，会尝试从其他线程那里窃取任务来执行，以此来平衡负载。
递归任务：ForkJoinPool中的RecursiveTask和RecursiveAction允许任务分解为子任务，并通过递归方式执行。

4. `Executors`工厂方法

java.util.concurrent.Executors提供了一些静态工厂方法来创建具有不同特性的线程池：

newFixedThreadPool：创建一个固定大小的线程池。
newSingleThreadExecutor：创建一个单线程的Executor，它只会创建一个线程来执行任务。
newCachedThreadPool：创建一个可缓存的线程池，如果线程池的当前规模超过了处理需求，将回收空闲的线程；当需求增加时，会增加新线程。
newScheduledThreadPool：创建一个大小无限的线程池，用于执行定时任务。

选择哪种线程池主要取决于你的具体需求。ThreadPoolExecutor提供了最大的灵活性和控制力，适合大多数情况。如果你需要定时或周期性地执行任务，ScheduledThreadPoolExecutor是更好的选择。对于可以并行处理的任务，ForkJoinPool能够提供高效的执行方式。而Executors提供的工厂方法则为创建常见类型的线程池提供了便捷。在实际应用中，理解每种线程池的特点和适用场景是非常重要的,也可以让大家在面试中关于线程池这块拿分。