void shutdown()

ExecutorService executor = Executors.newFixedThreadPool(4);
// 提交多個(gè)任務(wù)...
executor.shutdown();

try {
    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
        System.err.println("仍有任務(wù)未在時(shí)限內(nèi)完成");
    }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

List<Runnable> shutdownNow()

executor.shutdownNow();
// 典型返回值處理
List<Runnable> unprocessed = executor.shutdownNow();
if (!unprocessed.isEmpty()) {
    logger.warn("丟棄{}個(gè)未執(zhí)行任務(wù)", unprocessed.size());
}

class InterruptibleTask implements Runnable {
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            // 執(zhí)行可中斷的操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 重置中斷狀態(tài)
                break;
            }
        }
    }
}

public class GracefulShutdownExample {
    // 定義超時(shí)時(shí)間和時(shí)間單位（30秒）
    private static final int TIMEOUT = 30;
    private static final TimeUnit UNIT = TimeUnit.SECONDS;

    // 執(zhí)行任務(wù)的方法，接收一個(gè)任務(wù)列表并將其提交給線程池執(zhí)行
    public void executeTasks(List<Runnable> tasks) {
        // 創(chuàng)建一個(gè)固定大小的線程池，大小為系統(tǒng)可用處理器核心數(shù)
        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
        
        try {
            // 將任務(wù)列表中的每個(gè)任務(wù)提交到線程池
            tasks.forEach(executor::submit);
        } finally {
            // 在所有任務(wù)提交完后，禁用線程池接收新任務(wù)，開始優(yōu)雅關(guān)閉線程池
            executor.shutdown(); // 禁止再提交新任務(wù)
            try {
                // 等待線程池中的任務(wù)在指定超時(shí)內(nèi)完成，如果超時(shí)未完成，則強(qiáng)制關(guān)閉線程池
                if (!executor.awaitTermination(TIMEOUT, UNIT)) {
                    // 如果未能在超時(shí)內(nèi)完成，則調(diào)用 shutdownNow() 強(qiáng)制終止所有活動(dòng)任務(wù)
                    List<Runnable> unfinished = executor.shutdownNow();
                    // 處理未完成的任務(wù)，例如記錄日志或重新提交
                    handleUnfinishedTasks(unfinished);
                }
            } catch (InterruptedException e) {
                // 如果在等待終止時(shí)被中斷，恢復(fù)中斷狀態(tài)并強(qiáng)制關(guān)閉線程池
                Thread.currentThread().interrupt();
                executor.shutdownNow();
            }
        }
    }
    
    // 處理未完成任務(wù)的方法，這里我們打印未完成任務(wù)的數(shù)量
    private void handleUnfinishedTasks(List<Runnable> tasks) {
        // 如果有未完成的任務(wù)，打印任務(wù)數(shù)量并執(zhí)行額外的處理
        if (!tasks.isEmpty()) {
            System.out.println("未完成任務(wù)數(shù): " + tasks.size());
            // 可在此處記錄日志、重新排隊(duì)未完成的任務(wù)等
        }
    }

}

public class EnhancedExecutorManager {
    // 定義線程池對象
    private final ExecutorService executor;
    // 定義超時(shí)時(shí)間及單位
    private final long timeout;
    private final TimeUnit unit;

    // 構(gòu)造函數(shù)，初始化線程池并設(shè)置超時(shí)時(shí)間和單位
    public EnhancedExecutorManager(int corePoolSize, long timeout, TimeUnit unit) {
        // 創(chuàng)建一個(gè)核心池大小為 corePoolSize，最大池大小為 corePoolSize * 2，最大空閑時(shí)間 60秒的線程池
        this.executor = new ThreadPoolExecutor(
            corePoolSize,                             // 核心線程池大小
            corePoolSize * 2,                         // 最大線程池大小
            60L, TimeUnit.SECONDS,                    // 空閑線程的存活時(shí)間
            new LinkedBlockingQueue<>(1000),          // 使用容量為 1000 的隊(duì)列來緩存任務(wù)
            new CustomThreadFactory(),                // 自定義線程工廠
            new ThreadPoolExecutor.CallerRunsPolicy() // 當(dāng)任務(wù)無法提交時(shí)，調(diào)用者線程執(zhí)行該任務(wù)
        );
        this.timeout = timeout;                     // 設(shè)置超時(shí)時(shí)間
        this.unit = unit;                           // 設(shè)置超時(shí)時(shí)間單位
    }
    
    // 優(yōu)雅關(guān)閉線程池的方法
    public void shutdown() {
        executor.shutdown(); // 首先嘗試正常關(guān)閉線程池，不再接收新的任務(wù)
        
        try {
            // 如果線程池未能在指定的超時(shí)時(shí)間內(nèi)終止，則強(qiáng)制關(guān)閉
            if (!executor.awaitTermination(timeout, unit)) {
                System.out.println("強(qiáng)制終止線程池...");
                // 強(qiáng)制停止所有正在執(zhí)行的任務(wù)并返回丟棄的任務(wù)列表
                List<Runnable> droppedTasks = executor.shutdownNow();
                System.out.println("丟棄任務(wù)數(shù): " + droppedTasks.size());
            }
        } catch (InterruptedException e) {
            // 如果在等待過程中線程池關(guān)閉操作被中斷，立即強(qiáng)制關(guān)閉并恢復(fù)中斷狀態(tài)
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
    
    // 自定義線程工廠類，用于創(chuàng)建線程
    private static class CustomThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1); // 線程池編號(hào)，用于生成線程名
        private final ThreadGroup group; // 線程組
        private final AtomicInteger threadNumber = new AtomicInteger(1); // 線程編號(hào)
        private final String namePrefix; // 線程名稱前綴
    
        CustomThreadFactory() {
            // 獲取當(dāng)前系統(tǒng)的安全管理器，如果沒有，則使用當(dāng)前線程的線程組
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            // 設(shè)置線程池的名稱前綴
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() + // 線程池編號(hào)遞增
                         "-thread-";
        }
    
        // 創(chuàng)建新線程的方法
        public Thread newThread(Runnable r) {
            // 創(chuàng)建新的線程，線程組、名稱及優(yōu)先級(jí)均已設(shè)置
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0); // 默認(rèn)優(yōu)先級(jí)和daemon設(shè)置
            // 如果線程是守護(hù)線程，則將其設(shè)置為非守護(hù)線程
            if (t.isDaemon())
                t.setDaemon(false);
            // 設(shè)置線程優(yōu)先級(jí)為默認(rèn)
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t; // 返回新創(chuàng)建的線程
        }
    }
}

public class TieredShutdownManager { 
    // 定義三個(gè)優(yōu)先級(jí)的線程池列表：高優(yōu)先級(jí)、中優(yōu)先級(jí)、低優(yōu)先級(jí)
    private final List<ExecutorService> highPriority; 
    private final List<ExecutorService> normalPriority; 
    private final List<ExecutorService> lowPriority; 
  
    // 公共方法用于優(yōu)雅關(guān)閉所有線程池
    public void gracefulShutdown() { 
        // 依次關(guān)閉高、中、低優(yōu)先級(jí)的線程池
        shutdownTier(highPriority, 10, TimeUnit.SECONDS); 
        shutdownTier(normalPriority, 30, TimeUnit.SECONDS); 
        shutdownTier(lowPriority, 60, TimeUnit.SECONDS); 
    } 
  
    // 私有方法，用于優(yōu)雅關(guān)閉指定優(yōu)先級(jí)的線程池
    private void shutdownTier(List<ExecutorService> tier, long timeout, TimeUnit unit) { 
        // 對指定的線程池列表執(zhí)行關(guān)閉操作
        tier.forEach(ExecutorService::shutdown); 
  
        // 對每個(gè)線程池執(zhí)行等待終止的操作，指定超時(shí)時(shí)間
        tier.forEach(executor -> { 
            try { 
                // 如果線程池未在超時(shí)時(shí)間內(nèi)終止，則調(diào)用 shutdownNow 強(qiáng)制關(guān)閉
                if (!executor.awaitTermination(timeout, unit)) { 
                    executor.shutdownNow(); 
                } 
            } catch (InterruptedException e) { 
                // 如果在等待終止過程中線程被中斷，恢復(fù)中斷狀態(tài)并強(qiáng)制關(guān)閉線程池
                Thread.currentThread().interrupt(); 
                executor.shutdownNow(); 
            } 
        }); 
    } 
}

ThreadPoolExecutor executor = (ThreadPoolExecutor) service;
System.out.println("活躍線程數(shù): " + executor.getActiveCount());
System.out.println("完成任務(wù)數(shù): " + executor.getCompletedTaskCount());
System.out.println("隊(duì)列大小: " + executor.getQueue().size());

executor.setCorePoolSize(newSize);
executor.setMaximumPoolSize(newMaxSize);