Java异步判断线程池所有任务是否执行完成的操作方法

import java.util.concurrent.*;  
public class ThreadPoolExample {  
    public static void main(String[] args) throws InterruptedException {  
        // 创建一个包含固定数量线程的线程池  
        ExecutorService executorService = Executors.newFixedThreadPool(4);  
        // 定义任务数量  
        int taskCount = 10;  
        // 使用CountDownLatch来等待所有任务完成  
        final CountDownLatch latch = new CountDownLatch(taskCount);  
        // 提交任务到线程池  
        for (int i = 0; i < taskCount; i++) {  
            int taskId = i;  
            executorService.submit(() -> {  
                // 模拟任务执行  
                try {  
                    Thread.sleep(1000); // 假设每个任务需要1秒  
                } catch (InterruptedException e) {  
                    Thread.currentThread().interrupt();  
                }  
                System.out.println("任务 " + taskId + " 完成");  
                // 每完成一个任务，计数减一  
                latch.countDown();  
            });  
        }  
        // 等待所有任务完成  
        System.out.println("等待所有任务完成...");  
        latch.await(); // 阻塞当前线程，直到latch的计数达到零  
        System.out.println("所有任务完成！");  
        // 关闭线程池  
        executorService.shutdown();  
        // 可选：等待线程池中的线程都执行完毕  
        try {  
            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {  
                // 线程池没有在规定时间内关闭，则强制关闭  
                executorService.shutdownNow();  
            }  
        } catch (InterruptedException e) {  
            // 当前线程在等待过程中被中断  
            executorService.shutdownNow();  
            Thread.currentThread().interrupt();  
        }  
    }  
}

import java.util.ArrayList;  
import java.util.List;  
import java.util.concurrent.*;  
public class ThreadPoolFutureExample {  
    public static void main(String[] args) throws InterruptedException, ExecutionException {  
        // 创建一个包含固定数量线程的线程池  
        ExecutorService executorService = Executors.newFixedThreadPool(4);  
        // 创建一个Callable任务列表  
        List<Callable<String>> tasks = new ArrayList<>();  
        for (int i = 0; i < 10; i++) {  
            final int taskId = i;  
            tasks.add(() -> {  
                // 模拟任务执行  
                Thread.sleep(1000); // 假设每个任务需要1秒  
                return "任务 " + taskId + " 完成";  
            });  
        }  
        // 使用invokeAll提交所有任务，这将返回一个Future列表  
        List<Future<String>> futures = executorService.invokeAll(tasks);  
        // 遍历Future列表，获取每个任务的结果  
        for (Future<String> future : futures) {  
            // get()会阻塞，直到对应的任务完成  
            System.out.println(future.get());  
        }  
        // 关闭线程池  
        executorService.shutdown();  
        // 可选：等待线程池中的线程都执行完毕  
        try {  
            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {  
                // 线程池没有在规定时间内关闭，则强制关闭  
                executorService.shutdownNow();  
            }  
        } catch (InterruptedException e) {  
            // 当前线程在等待过程中被中断  
            executorService.shutdownNow();  
            Thread.currentThread().interrupt();  
        }  
    }  
}  
// 注意：这里使用了Lambda表达式和方法引用来简化Callable的创建  
// 实际使用中，你可能需要实现Callable接口或使用匿名内部类

import java.util.ArrayList;  
import java.util.List;  
import java.util.concurrent.*;  
public class ThreadPoolFutureCompleteExample {  
    public static void main(String[] args) {  
        // 创建一个包含固定数量线程的线程池  
        ExecutorService executorService = Executors.newFixedThreadPool(4);  
        // 创建一个Callable任务列表  
        List<Callable<String>> tasks = new ArrayList<>();  
        for (int i = 0; i < 10; i++) {  
            final int taskId = i;  
            tasks.add(new Callable<String>() {  
                @Override  
                public String call() throws Exception {  
                    // 模拟任务执行  
                    TimeUnit.SECONDS.sleep(1); // 假设每个任务需要1秒  
                    return "任务 " + taskId + " 完成";  
                }  
            });  
            // 或者使用Lambda表达式（如果你使用的是Java 8或更高版本）  
            // tasks.add(() -> {  
            //     TimeUnit.SECONDS.sleep(1);  
            //     return "任务 " + taskId + " 完成";  
            // });  
        }  
        try {  
            // 使用invokeAll提交所有任务，这将返回一个Future列表  
            List<Future<String>> futures = executorService.invokeAll(tasks);  
            // 遍历Future列表，获取每个任务的结果  
            for (Future<String> future : futures) {  
                // get()会阻塞，直到对应的任务完成  
                System.out.println(future.get());  
            }  
            // 关闭线程池  
            executorService.shutdown();  
            // 等待线程池中的所有线程都执行完毕（可选）  
            // 注意：由于我们已经调用了invokeAll并等待了所有Future的完成，这一步通常是多余的  
            // 但为了完整性，我还是展示了如何等待线程池关闭  
            boolean terminated = executorService.awaitTermination(60, TimeUnit.SECONDS);  
            if (!terminated) {  
                // 如果线程池没有在规定时间内关闭，则强制关闭  
                System.err.println("线程池没有在规定时间内关闭，尝试强制关闭...");  
                executorService.shutdownNow();  
                // 注意：shutdownNow()不保证已经提交的任务会被取消  
                // 它会尝试停止正在执行的任务，但已经开始执行的任务可能无法被中断  
            }  
        } catch (InterruptedException | ExecutionException e) {  
            // 处理异常  
            e.printStackTrace();  
            // 如果当前线程在等待过程中被中断，尝试关闭线程池  
            if (!executorService.isShutdown()) {  
                executorService.shutdownNow();  
            }  
            // 根据需要，可能还需要重新设置中断状态  
            Thread.currentThread().interrupt();  
        }  
    }  
}