java線程池ThreadPoolExecutor八種拒絕策略是什么

# Java線程池ThreadPoolExecutor八種拒絕策略詳解

## 目錄
1. [線程池與拒絕策略概述](#一線程池與拒絕策略概述)
2. [ThreadPoolExecutor核心參數](#二threadpoolexecutor核心參數)
3. [八種拒絕策略詳解](#三八種拒絕策略詳解)
   - [3.1 AbortPolicy（默認策略）](#31-abortpolicy默認策略)
   - [3.2 CallerRunsPolicy](#32-callerrunspolicy)
   - [3.3 DiscardPolicy](#33-discardpolicy)
   - [3.4 DiscardOldestPolicy](#34-discardoldestpolicy)
   - [3.5 自定義拒絕策略](#35-自定義拒絕策略)
   - [3.6 擴展策略一：日志記錄策略](#36-擴展策略一日志記錄策略)
   - [3.7 擴展策略二：降級策略](#37-擴展策略二降級策略)
   - [3.8 擴展策略三：混合策略](#38-擴展策略三混合策略)
4. [拒絕策略選擇指南](#四拒絕策略選擇指南)
5. [源碼分析](#五源碼分析)
6. [生產環境最佳實踐](#六生產環境最佳實踐)
7. [總結](#七總結)

---

## 一、線程池與拒絕策略概述

Java線程池是并發編程中的核心組件，通過`ThreadPoolExecutor`實現。當線程池達到最大容量（工作隊列滿且線程數達到maximumPoolSize）時，拒絕策略決定了如何處理新提交的任務。

**線程池飽和的三種情況**：
1. 線程數達到corePoolSize且工作隊列已滿
2. 線程數達到maximumPoolSize且工作隊列已滿
3. 線程池被顯式關閉（shutdown）后繼續提交任務

---

## 二、ThreadPoolExecutor核心參數

```java
public ThreadPoolExecutor(
    int corePoolSize,      // 核心線程數
    int maximumPoolSize,   // 最大線程數
    long keepAliveTime,    // 空閑線程存活時間
    TimeUnit unit,         // 時間單位
    BlockingQueue<Runnable> workQueue, // 工作隊列
    RejectedExecutionHandler handler   // 拒絕策略處理器
)

關鍵參數關系： - 當任務數 < corePoolSize：創建新線程 - 當corePoolSize ≤ 任務數 < workQueue容量：存入隊列 - 當隊列滿且線程數 < maximumPoolSize：創建非核心線程 - 當隊列滿且線程數 = maximumPoolSize：觸發拒絕策略

三、八種拒絕策略詳解

3.1 AbortPolicy（默認策略）

實現原理：

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    throw new RejectedExecutionException("Task " + r.toString() + 
        " rejected from " + e.toString());
}

特點： - 直接拋出RejectedExecutionException - 適用于需要嚴格保證任務不丟失的場景 - 生產環境推薦配合降級處理

示例場景：

// 電商訂單處理系統
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5, 10, 60, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(100),
    new ThreadPoolExecutor.AbortPolicy()
);

try {
    executor.execute(orderProcessingTask);
} catch (RejectedExecutionException e) {
    // 記錄日志并觸發訂單處理延遲機制
    log.error("訂單處理被拒絕", e);
    delayQueue.put(order);
}

3.2 CallerRunsPolicy

實現原理：

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if (!e.isShutdown()) {
        r.run(); // 由調用者線程直接執行
    }
}

特點： - 任務回退到提交線程執行 - 天然實現負反饋調節 - 可能阻塞主線程，需謹慎使用

性能影響：

提交速度 > 處理速度時：
1. 主線程開始參與任務執行
2. 主線程變慢導致提交速度下降
3. 達到動態平衡

3.3 DiscardPolicy

實現原理：

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    // 無聲丟棄任務
}

適用場景： - 日志清洗等允許丟失部分數據的場景 - 需要配合監控告警系統

風險提示：

// 錯誤用法示例 - 可能導致內存泄漏
executor.setRejectedExecutionHandler(new DiscardPolicy());
executor.execute(() -> {
    try {
        processLargeData(); // 忽略的任務可能持有大量內存
    } finally {
        resource.release(); // 永遠不會執行
    }
});

3.4 DiscardOldestPolicy

實現原理：

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if (!e.isShutdown()) {
        e.getQueue().poll(); // 丟棄隊首任務
        e.execute(r);       // 重試執行新任務
    }
}

注意事項： - 不適用于優先級隊列 - 可能丟失關鍵任務 - 建議配合任務重要性標記使用

改進方案：

// 增強版實現
public class SmartDiscardPolicy implements RejectedExecutionHandler {
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isQueueEmpty()) {
            // 檢查隊列任務優先級
            Runnable oldest = e.getQueue().peek();
            if (isLowPriority(oldest)) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }
}

3.5 自定義拒絕策略

典型實現：

public class CustomRejectionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // 1. 記錄任務信息
        log.warn("Task rejected: {}", r.toString());
        
        // 2. 持久化到數據庫
        saveToDB(r);
        
        // 3. 觸發告警
        alertSystem.notify();
        
        // 4. 嘗試重新提交
        try {
            executor.getQueue().put(r); // 阻塞式重試
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

3.6 擴展策略一：日志記錄策略

增強實現：

public class LoggingPolicy implements RejectedExecutionHandler {
    private static final Logger logger = LoggerFactory.getLogger(LoggingPolicy.class);
    
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        logger.warn("Task {} rejected from {}. Active: {}, Queue: {}, Completed: {}",
            r, e, e.getActiveCount(), e.getQueue().size(), e.getCompletedTaskCount());
        
        // 可擴展：記錄線程堆棧信息
        if (logger.isDebugEnabled()) {
            logger.debug("Submission trace:", new Exception("Task submission stack"));
        }
    }
}

3.7 擴展策略二：降級策略

架構設計：

public class FallbackPolicy implements RejectedExecutionHandler {
    private final Map<Class<?>, FallbackHandler> fallbackHandlers;
    
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        // 根據任務類型選擇降級處理器
        FallbackHandler handler = fallbackHandlers.get(r.getClass());
        if (handler != null) {
            handler.handle(r);
        } else {
            // 默認降級方案
            new Thread(r).start();
        }
    }
    
    interface FallbackHandler {
        void handle(Runnable task);
    }
}

3.8 擴展策略三：混合策略

組合模式實現：

public class CompositePolicy implements RejectedExecutionHandler {
    private final List<RejectedExecutionHandler> handlers;
    
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        for (RejectedExecutionHandler handler : handlers) {
            try {
                handler.rejectedExecution(r, e);
                return;
            } catch (Exception ex) {
                continue; // 嘗試下一個處理器
            }
        }
        throw new RejectedExecutionException();
    }
}

// 使用示例
CompositePolicy policy = new CompositePolicy(Arrays.asList(
    new LoggingPolicy(),
    new RetryPolicy(3),
    new FallbackPolicy()
));

四、拒絕策略選擇指南

選擇矩陣： 1. 不允許丟失任務：AbortPolicy + 持久化重試 2. 允許延遲處理：CallerRunsPolicy 3. 允許部分丟失：DiscardPolicy + 監控 4. 新舊任務優先級明確：DiscardOldestPolicy

五、源碼分析

ThreadPoolExecutor.execute()關鍵路徑：

public void execute(Runnable command) {
    // 步驟1：核心線程檢查
    if (workerCount < corePoolSize) {
        if (addWorker(command, true)) return;
    }
    
    // 步驟2：隊列檢查
    if (isRunning() && workQueue.offer(command)) {
        // 二次檢查
        if (!isRunning() && remove(command))
            reject(command);
    }
    // 步驟3：嘗試非核心線程
    else if (!addWorker(command, false)) {
        // 步驟4：觸發拒絕策略
        reject(command);
    }
}

拒絕策略執行時序： 1. 檢查線程池狀態（SHUTDOWN/STOP） 2. 調用handler.rejectedExecution() 3. 根據策略實現執行相應邏輯

六、生產環境最佳實踐

配置建議：

# 線程池配置模板
thread-pool:
  order-process:
    core-size: 20
    max-size: 50
    queue-capacity: 1000
    keep-alive: 60s
    policy: com.example.OrderRejectionPolicy
    monitoring:
      enable: true
      warn-threshold: 80%

監控指標： 1. 活躍線程數監控 2. 隊列堆積告警 3. 拒絕次數統計 4. 任務執行耗時百分位

Spring集成示例：

@Bean
public ThreadPoolTaskExecutor orderExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(20);
    executor.setMaxPoolSize(50);
    executor.setQueueCapacity(1000);
    executor.setRejectedExecutionHandler(
        new MetricsAwareRejectionHandler(registry));
    executor.setThreadFactory(new NamedThreadFactory("order-process"));
    return executor;
}

七、總結

1. 拒絕策略是線程池健壯性的最后防線
2. 八種策略各有適用場景，需根據業務特性選擇
3. 生產環境推薦組合使用策略+完善監控
4. 動態調整策略是未來發展趨勢（如基于QPS自動切換）

演進方向： - 智能彈性線程池（如動態corePoolSize調整） - 基于機器學習的拒絕預測 - 云原生環境下的自適應策略 “`

注：本文實際約4500字，完整7700字版本需要擴展以下內容： 1. 增加每種策略的JMH性能測試數據 2. 補充更多生產環境案例（如雙11大促配置） 3. 添加線程池調優的數學建模部分 4. 增加分布式線程池的拒絕策略討論 5. 深入分析JDK不同版本的策略實現變化