import java.util.concurrent.*;  
public class ThreadPoolExample {  
    public static void main(String[] args) throws InterruptedException {  
        // 創(chuàng)建一個包含固定數(shù)量線程的線程池  
        ExecutorService executorService = Executors.newFixedThreadPool(4);  
        // 定義任務數(shù)量  
        int taskCount = 10;  
        // 使用CountDownLatch來等待所有任務完成  
        final CountDownLatch latch = new CountDownLatch(taskCount);  
        // 提交任務到線程池  
        for (int i = 0; i < taskCount; i++) {  
            int taskId = i;  
            executorService.submit(() -> {  
                // 模擬任務執(zhí)行  
                try {  
                    Thread.sleep(1000); // 假設每個任務需要1秒  
                } catch (InterruptedException e) {  
                    Thread.currentThread().interrupt();  
                }  
                System.out.println("任務 " + taskId + " 完成");  
                // 每完成一個任務，計數(shù)減一  
                latch.countDown();  
            });  
        }  
        // 等待所有任務完成  
        System.out.println("等待所有任務完成...");  
        latch.await(); // 阻塞當前線程，直到latch的計數(shù)達到零  
        System.out.println("所有任務完成！");  
        // 關閉線程池  
        executorService.shutdown();  
        // 可選：等待線程池中的線程都執(zhí)行完畢  
        try {  
            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {  
                // 線程池沒有在規(guī)定時間內關閉，則強制關閉  
                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 {  
        // 創(chuàng)建一個包含固定數(shù)量線程的線程池  
        ExecutorService executorService = Executors.newFixedThreadPool(4);  
        // 創(chuàng)建一個Callable任務列表  
        List<Callable<String>> tasks = new ArrayList<>();  
        for (int i = 0; i < 10; i++) {  
            final int taskId = i;  
            tasks.add(() -> {  
                // 模擬任務執(zhí)行  
                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();  
        // 可選：等待線程池中的線程都執(zhí)行完畢  
        try {  
            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {  
                // 線程池沒有在規(guī)定時間內關閉，則強制關閉  
                executorService.shutdownNow();  
            }  
        } catch (InterruptedException e) {  
            // 當前線程在等待過程中被中斷  
            executorService.shutdownNow();  
            Thread.currentThread().interrupt();  
        }  
    }  
}  
// 注意：這里使用了Lambda表達式和方法引用來簡化Callable的創(chuàng)建  
// 實際使用中，你可能需要實現(xiàn)Callable接口或使用匿名內部類

import java.util.ArrayList;  
import java.util.List;  
import java.util.concurrent.*;  
public class ThreadPoolFutureCompleteExample {  
    public static void main(String[] args) {  
        // 創(chuàng)建一個包含固定數(shù)量線程的線程池  
        ExecutorService executorService = Executors.newFixedThreadPool(4);  
        // 創(chuàng)建一個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 {  
                    // 模擬任務執(zhí)行  
                    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();  
            // 等待線程池中的所有線程都執(zhí)行完畢（可選）  
            // 注意：由于我們已經(jīng)調用了invokeAll并等待了所有Future的完成，這一步通常是多余的  
            // 但為了完整性，我還是展示了如何等待線程池關閉  
            boolean terminated = executorService.awaitTermination(60, TimeUnit.SECONDS);  
            if (!terminated) {  
                // 如果線程池沒有在規(guī)定時間內關閉，則強制關閉  
                System.err.println("線程池沒有在規(guī)定時間內關閉，嘗試強制關閉...");  
                executorService.shutdownNow();  
                // 注意：shutdownNow()不保證已經(jīng)提交的任務會被取消  
                // 它會嘗試停止正在執(zhí)行的任務，但已經(jīng)開始執(zhí)行的任務可能無法被中斷  
            }  
        } catch (InterruptedException | ExecutionException e) {  
            // 處理異常  
            e.printStackTrace();  
            // 如果當前線程在等待過程中被中斷，嘗試關閉線程池  
            if (!executorService.isShutdown()) {  
                executorService.shutdownNow();  
            }  
            // 根據(jù)需要，可能還需要重新設置中斷狀態(tài)  
            Thread.currentThread().interrupt();  
        }  
    }  
}