java 线程池监听结束

原创

mob649e81567471 2024-10-27 04:09:38 ©著作权

文章标签 线程池 java Java 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者mob649e81567471的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java 线程池及监听任务结束

多线程编程是Java中的一个重要概念，而线程池作为管理多线程的重要工具，能够有效提升性能并降低资源消耗。在本文中，我们将探讨如何使用Java线程池，并实现任务完成的监听。

什么是线程池？

线程池是一种多线程处理模型，它能够维护一组线程并根据需要复用这些线程来执行任务。使用线程池的主要好处包括：

资源管理：通过复用线程，减少创建和销毁线程的开销。
任务调度：可以高效地调度任务，控制并发数量。
异步处理：可以将任务提交到线程池，立即返回结果，而不是等待任务完成。

Java 线程池的使用

Java提供了java.util.concurrent包中的Executor框架来使用线程池。下面是一个基本示例，展示如何创建一个线程池，并提交任务：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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

        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executorService.submit(() -> {
                System.out.println("任务 " + taskId + " 开始执行");
                try {
                    // 模拟任务执行过程
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("任务 " + taskId + " 完成");
            });
        }

        executorService.shutdown(); // 关闭线程池
    }
}

在上面的代码中，我们创建了一个固定大小为3的线程池，提交了5个任务。每个任务会模拟执行2秒，完成后会输出状态信息。

监听任务结束

为了监听任务的结束，我们可以使用Future对象。Future表示异步计算的结果，我们可以通过它来检查任务是否完成。这是通过ExecutorService.submit()方法返回的。

以下是增强过的代码示例，加入了监听任务结束的功能：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadPoolListenerExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        List<Future<String>> futures = new ArrayList<>();

        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            Future<String> future = executorService.submit(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    System.out.println("任务 " + taskId + " 开始执行");
                    Thread.sleep(2000); // 模拟任务执行
                    return "任务 " + taskId + " 完成";
                }
            });
            futures.add(future);
        }

        executorService.shutdown(); // 关闭线程池

        // 监听任务结束
        for (Future<String> future : futures) {
            try {
                String result = future.get(); // 阻塞，直到任务完成
                System.out.println(result);
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个示例中，我们使用Callable来提交任务，并将返回的Future对象保存到列表中。随后我们在主线程中循环遍历这些Future对象，通过调用get()方法来监听每个任务的结束。

可视化表现

在任务执行过程中，我们可以用甘特图和旅行图来可视化线程的调度状态。以下是相应的Mermaid图表示：

甘特图

gantt
    title 线程任务甘特图
    dateFormat  YYYY-MM-DD
    section 任务执行
    任务 0 :a0, 2023-10-01, 2d
    任务 1 :after a0  , 2d
    任务 2 :after a0  , 2d
    任务 3 :after a0  , 2d
    任务 4 :after a0  , 2d

旅行图

journey
    title 线程任务执行过程
    section 任务执行
      任务 0:待执行       :task0, 5: 不完全
      任务 1: 进行中      :task1, 3: 完全
      任务 2:完成         :task2, 5: 完全
      任务 3:完成         :task3, 5: 完全
      任务 4:完成         :task4, 5: 完全