在 Java 中，Executors類提供了多種靜態工廠方法來創建不同類型的線程池。學習線程池時，Executors類不可或缺。掌握其用法、原理和適用場景，有助于在實際項目開發中順利應用。以下是一些常用方法，我將逐一解釋。

這些方法提供了靈活的方式來創建和管理線程池，以滿足不同的并發需求。下面，我將詳細介紹這 9 種方法的實現和使用場景。

1. newCachedThreadPool()

newCachedThreadPool方法是 Java java.util.concurrent包中Executors類的靜態工廠方法。此方法創建一個可緩存線程池，可根據需要動態創建新線程，并終止在一定時間內未使用的空閑線程。

(1) 實現原理

• 線程創建：當向線程池提交任務時，如果當前線程數小于核心池大小，將創建新線程。
• 線程重用：如果當前線程數等于核心池大小，新任務將被放入任務隊列等待執行。
• 線程終止：空閑線程在指定時間（默認為 60 秒）內未被使用將被終止，以減少資源消耗。

(2) 源代碼分析

在 Java 的java.util.concurrent包中，Executors類并不直接提供newCachedThreadPool的實現。相反，它使用ThreadPoolExecutor構造函數。以下是ThreadPoolExecutor調用的示例：

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                   60L, TimeUnit.SECONDS,
                                   new SynchronousQueue());
}

(3) 參數解釋

• corePoolSize：核心線程數，這里設置為 0，表示線程池不保留任何核心線程。
• maximumPoolSize：最大線程數，設置為Integer.MAX_VALUE，理論上允許無限數量的線程。
• keepAliveTime：多余空閑線程在終止前等待新任務的最長時間，這里設置為 60 秒。
• unit：keepAliveTime參數的時間單位，這里是秒。
• workQueue：任務隊列。這里使用SynchronousQueue，這是一個不存儲元素的阻塞隊列，要求每個插入操作都等待相應的移除操作。

(4) 實現過程

• 初始化：調用newCachedThreadPool時，創建一個ThreadPoolExecutor實例。
• 任務提交：向線程池提交任務時，池檢查是否有空閑線程可用于執行任務。
• 線程創建：如果沒有空閑線程且當前線程數小于maximumPoolSize，則創建新線程來執行任務。
• 任務隊列：如果當前線程數已達到maximumPoolSize，任務將被放入SynchronousQueue等待執行。
• 線程重用：線程完成任務后，不會立即終止，而是嘗試從SynchronousQueue獲取新任務。
• 線程終止：如果線程在keepAliveTime內未收到新任務，將終止。

這種設計使newCachedThreadPool非常適合處理大量短期異步任務，因為它可以動態調整線程數量以適應不同的工作負載。然而，由于它可以創建無限數量的線程，因此必須考慮任務的特性和系統資源限制，以防止資源耗盡。

(5) 使用場景

適用于執行許多短期異步任務，特別是當任務的執行時間不確定時。例如，處理 Web 服務器上的大量并發請求或異步日志記錄。

2. newFixedThreadPool(int nThreads)

newFixedThreadPool(int nThreads)方法是 Java java.util.concurrent包中Executors類的靜態工廠方法。此方法創建一個具有固定線程數的線程池，確保池中的線程數量保持不變。

(1) 實現原理

• 固定線程數：線程池中的線程數量始終保持為nThreads。
• 任務隊列：提交到池中的任務首先由核心線程執行。如果所有核心線程都忙碌，新任務將被放入阻塞隊列等待執行。
• 線程重用：池中的線程會被重用；完成一個任務后，線程將立即嘗試從隊列中獲取下一個任務執行。

(2) 源代碼分析

newFixedThreadPool方法通過調用ThreadPoolExecutor類的構造函數來實現。以下是ThreadPoolExecutor調用的示例：

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(
        nThreads, 
        nThreads, 
        0L,      
        TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue() 
    );
}

(3) 參數解釋

• corePoolSize：核心線程數，設置為nThreads，表示池始終有nThreads個線程。
• maximumPoolSize：最大線程數，也設置為nThreads，確保池大小不超過nThreads。
• keepAliveTime：多余空閑線程在終止前等待新任務的最長時間，這里設置為 0，表示任何超過核心池大小的線程將立即終止。
• unit：keepAliveTime參數的時間單位，這里是毫秒。
• workQueue：任務隊列。這里使用LinkedBlockingQueue，這是一個基于鏈表的阻塞隊列，可以存儲任意數量的任務。

(4) 實現過程

• 初始化：調用newFixedThreadPool時，創建一個ThreadPoolExecutor實例。
• 任務提交：向池提交任務時，檢查是否有空閑核心線程可立即執行任務。
• 任務隊列：如果所有核心線程都忙碌，新任務將被放入LinkedBlockingQueue等待執行。
• 線程重用：核心線程完成任務后，將嘗試從LinkedBlockingQueue獲取新任務繼續執行。
• 線程數控制：由于keepAliveTime設置為 0，任何超過核心池大小的線程將立即終止，確保池中的線程數量不超過nThreads。

這種設計使newFixedThreadPool非常適合處理大量穩定的任務流，因為它確保任務由固定數量的線程并行執行，避免線程不受控制地增長。然而，由于池大小是固定的，如果任務提交速率超過池的處理能力，任務可能會在隊列中長時間等待。因此，使用newFixedThreadPool時，根據任務的特性和預期工作負載設置nThreads非常重要。

(5) 使用場景

適用于執行大量長時間運行的任務，且需要固定線程數量的情況。例如，同時運行多個數據加載或數據處理任務，同時限制并發以避免資源過載。

3. newSingleThreadExecutor()

newSingleThreadExecutor方法是 Java java.util.concurrent包中Executors類的靜態工廠方法。此方法創建一個單線程執行器，確保所有任務按提交順序依次執行，使用單個線程。

(1) 實現原理

• 單線程執行：線程池只包含一個線程，確保所有任務由這個單線程按順序執行。
• 任務隊列：如果在單線程忙碌時提交新任務，任務將被放入阻塞隊列等待執行。
• 線程重用：單線程會被重用；完成一個任務后，它將立即嘗試從隊列中獲取下一個任務執行。

(2) 源代碼分析

newSingleThreadExecutor方法通過調用ThreadPoolExecutor類的構造函數來實現。以下是ThreadPoolExecutor調用的示例：

public static ExecutorService newSingleThreadExecutor() {
    return new ThreadPoolExecutor(
        1, 
        1, 
        0L, TimeUnit.MILLISECONDS, 
        new LinkedBlockingQueue() 
    );
}

(3) 參數解釋

• corePoolSize：核心線程數，設置為 1，表示池始終有一個核心線程。
• maximumPoolSize：最大線程數，也設置為 1，確保池大小不超過一個線程。
• keepAliveTime：多余空閑線程在終止前等待新任務的最長時間，這里設置為 0，表示線程空閑時將立即終止。
• unit：keepAliveTime參數的時間單位，這里是毫秒。
• workQueue：任務隊列。這里使用LinkedBlockingQueue，這是一個可以存儲任意數量任務的阻塞隊列。

(4) 實現過程

• 初始化：調用newSingleThreadExecutor時，創建一個ThreadPoolExecutor實例。
• 任務提交：向池提交任務時，如果核心線程空閑，它將立即執行任務；如果核心線程忙碌，任務將被放入LinkedBlockingQueue等待。
• 順序執行：由于只有一個線程，所有任務按提交順序執行。
• 任務隊列：如果核心線程正在執行任務，新任務將被放入LinkedBlockingQueue等待。
• 線程重用：核心線程完成任務后，將嘗試從LinkedBlockingQueue獲取新任務繼續執行。
• 線程數控制：由于keepAliveTime設置為 0，核心線程在沒有任務可執行時將立即終止。然而，因為corePoolSize和maximumPoolSize都為 1，線程池將立即重新創建一個新線程。

這種設計使newSingleThreadExecutor非常適合需要保證任務順序執行的場景，例如任務有依賴關系或必須按特定順序執行的情況。此外，由于只有一個線程，它避免了多線程環境中固有的并發問題。然而，單線程執行也限制了并行處理能力；如果一個任務執行時間較長，后續任務可能會經歷顯著的延遲。因此，使用newSingleThreadExecutor時，考慮任務的性質和順序執行的要求非常重要。

(5) 使用場景

• 保證順序執行：適用于需要任務按特定順序執行的場景，例如隊列中消息或事件的順序處理。
• 單后臺線程執行定期任務：適用于需要單個后臺線程持續處理定期任務的情況。

通過使用newSingleThreadExecutor，開發人員可以確保任務按提交順序執行，而無需管理多個線程的復雜性和潛在問題。

4. newScheduledThreadPool(int corePoolSize)

newScheduledThreadPool方法是 Java java.util.concurrent包中Executors類的靜態工廠方法。此方法用于創建一個固定大小的線程池，支持執行定時和周期性任務。

(1) 實現原理

• 定時任務：線程池可以執行具有指定延遲或固定間隔的任務。
• 固定線程數：池中的線程數量限制為corePoolSize指定的大小。
• 任務隊列：任務首先由核心線程執行。如果所有核心線程都忙碌，新任務將被放入延遲隊列等待執行。

(2) 源代碼分析

newScheduledThreadPool方法通過調用ScheduledThreadPoolExecutor類的構造函數來實現。以下是調用示例：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

ScheduledThreadPoolExecutor是ThreadPoolExecutor的子類，專門用于執行定時任務。ScheduledThreadPoolExecutor構造函數的corePoolSize參數定義了池中核心線程的數量。

內部，ScheduledThreadPoolExecutor使用DelayedWorkQueue作為其任務隊列，該隊列根據任務的預定執行時間對任務進行排序。

(3) 實現過程

• 初始化：調用newScheduledThreadPool時，創建一個ScheduledThreadPoolExecutor實例。
• 任務提交：向池提交任務時，根據其預定執行時間將其放入DelayedWorkQueue。
• 任務調度：池中的線程從DelayedWorkQueue中獲取任務，并在預定時間到達時執行它們。
• 線程重用：完成任務的線程將嘗試從DelayedWorkQueue獲取下一個任務。
• 線程數控制：如果任務數量超過核心線程的處理能力，ScheduledThreadPoolExecutor將創建新線程來幫助處理任務，最多達到corePoolSize定義的限制。

(4) 特性

• 線程工廠：ScheduledThreadPoolExecutor允許設置線程工廠來創建具有特定屬性的線程。
• 拒絕執行處理程序：它允許設置RejectedExecutionHandler來處理無法接受的任務（例如，當池關閉或任務隊列已滿時）。
• 關閉行為：與ThreadPoolExecutor不同，ScheduledThreadPoolExecutor的shutdown和shutdownNow方法不會等待延遲任務完成。

newScheduledThreadPool方法非常適合需要執行定時任務的場景，例如周期性后臺任務或計劃在特定時間運行的任務。然而，由于它基于固定大小的線程池，在高負載下，任務可能會排隊等待執行。因此，在設計時考慮適當的corePoolSize以滿足性能要求非常重要。

(5) 使用場景

• 周期性任務執行：適用于需要定期執行任務的場景，例如定期數據備份或周期性狀態檢查。
• 延遲任務執行：適用于需要在未來某個時間點執行的任務，例如發送提醒或計劃更新。

通過使用newScheduledThreadPool，開發人員可以有效地管理和調度需要在固定間隔或特定時間執行的任務，確保任務由固定數量的線程正確處理。

5. newWorkStealingPool(int parallelism)

newWorkStealingPool(int parallelism)方法是 Java 8 中引入的java.util.concurrent包中Executors類的靜態工廠方法。此方法創建一個工作竊取線程池，可提高并行任務的執行效率，特別是在多處理器系統上。

(1) 實現原理

• 工作竊取：在工作竊取線程池中，每個線程都有自己的任務隊列。當一個線程完成其任務時，它會嘗試從其他線程的隊列中“竊取”任務。
• 并行級別：線程池的大小由parallelism參數確定，通常等于主機上的處理器核心數量。
• 動態調整：工作竊取線程池可以動態添加或刪除線程，以適應任務負載和線程利用率。

(2) 源代碼分析

newWorkStealingPool方法通過調用ForkJoinPool類的靜態工廠方法來實現。以下是調用示例：

public static ExecutorService newWorkStealingPool(int parallelism) {
    return new ForkJoinPool(
        parallelism,
        ForkJoinPool.defaultForkJoinWorkerThreadFactory,
        null, 
        false 
    );
}

(3) 參數解釋

• parallelism：并行級別，即線程池中的線程數量。
• ForkJoinPool.defaultForkJoinWorkerThreadFactory：用于創建線程的默認線程工廠。
• null：未捕獲異常處理程序，這里未指定，因此如果任務拋出未捕獲異常，它將傳播到ForkJoinTask的調用者。
• false：表示這不是異步任務。

ForkJoinPool內部使用ForkJoinWorkerThread來執行任務，每個線程都有一個ForkJoinQueue來存儲任務。

(4) 實現過程

• 初始化：調用newWorkStealingPool時，創建一個ForkJoinPool實例。
• 任務提交：向池提交任務時，任務被放入調用線程的本地隊列。
• 任務執行：每個線程首先嘗試從其本地隊列執行任務。
• 工作竊?。喝绻镜仃犃袨榭?，線程嘗試從其他線程的隊列中竊取任務。
• 動態調整：線程池可以根據需要動態添加或刪除線程。

(5) 特性

• 工作竊?。哼@種機制特別適合工作負載不均勻分布的情況，因為它減少了空閑時間并提高了資源利用率。
• 并行計算：適合可以分解為多個子任務的并行計算任務，因為任務可以被分割并將子任務提交到線程池。
• 減少競爭：由于每個線程都有自己的隊列，鎖競爭減少，提高了并發性能。

newWorkStealingPool非常適合需要高并發和高吞吐量的場景，特別是在多處理器系統上。然而，由于工作竊取機制，它可能不適合任務執行時間非常短或任務數量非常少的場景，因為竊取本身可能會引入額外的開銷。

(6) 使用場景

• 不均勻工作負載：適用于工作負載不均勻或可以分解為多個較小任務的任務，如圖像處理或數據分析。
• 多核處理器利用：有效利用多核處理器的所有核心。

通過使用newWorkStealingPool，開發人員可以有效地管理和執行并行任務，充分利用多核處理器的能力并提高并發應用程序的性能。

6. newSingleThreadScheduledExecutor()

newSingleThreadScheduledExecutor是 Java java.util.concurrent包中Executors類的靜態工廠方法。此方法創建一個單線程調度執行器，可調度命令在給定延遲后運行或定期執行。

(1) 實現原理

• 單線程執行：執行器確保所有任務在單個線程中按順序執行，維護任務執行順序。
• 定時任務：支持延遲和定期任務執行。
• 任務隊列：所有任務首先被放入任務隊列，然后由單個線程按順序執行。

(2) 源代碼分析

newSingleThreadScheduledExecutor方法通過調用ScheduledThreadPoolExecutor類的構造函數來實現。以下是調用示例：

public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
    return new ScheduledThreadPoolExecutor(1);
}

這里，ScheduledThreadPoolExecutor是ExecutorService的一個實現，專門用于執行定時任務。構造函數有一個參數，即核心池大小。將其設置為 1 表示這是一個單線程執行器。

ScheduledThreadPoolExecutor內部使用DelayedWorkQueue作為任務隊列。此隊列可以根據任務的預定執行時間對任務進行排序。

(3) 實現過程

• 初始化：調用newSingleThreadScheduledExecutor時，創建一個核心池大小為 1 的ScheduledThreadPoolExecutor實例。
• 任務提交：向執行器提交任務時，它被包裝成ScheduledFutureTask或RunnableScheduledFuture并放入DelayedWorkQueue。
• 任務調度：單線程不斷從DelayedWorkQueue獲取任務，并在預定時間執行它們。如果執行時間已到，任務將被執行；如果未到，線程將等待直到執行時間到達。
• 順序執行：由于只有一個線程，所有任務按提交順序執行。
• 定期任務：對于需要定期執行的任務，執行器在每次執行后重新計算下一次執行時間，并將任務放回隊列。

(4) 特性

• 順序維護：newSingleThreadScheduledExecutor非常適合需要維護任務順序的場景，例如任務有依賴關系或特定順序的情況。
• 并發簡化：只有一個線程避免了并發問題，簡化了任務同步和狀態管理。
• 定時執行：它為任務提供了強大的調度功能，例如定期維護或后臺任務。

(5) 使用場景

• 順序任務執行：適用于任務需要按特定順序執行或有依賴關系的場景。
• 定時后臺任務：適用于需要定期執行的任務，例如定期系統檢查或維護任務。

7. privilegedThreadFactory()

privilegedThreadFactory是 Java java.util.concurrent包中Executors類的靜態工廠方法。此方法創建一個線程工廠，生成具有特權訪問權限的線程。這些線程可以訪問系統屬性、加載系統庫和訪問文件系統。

(1) 實現原理

• 特權訪問：此工廠創建的線程有權訪問系統資源，如加載系統屬性和庫。
• 線程創建：線程工廠創建新的線程實例，這些實例繼承創建它們的線程的上下文。

(2) 源代碼分析

privilegedThreadFactory方法的實現細節在標準 Java 庫中未公開暴露。然而，我們可以通過檢查其一般工作方式來理解其功能。以下是privilegedThreadFactory方法可能的調用示例：

public static ThreadFactory privilegedThreadFactory() {
    return new PrivilegedThreadFactory();
}

這里，PrivilegedThreadFactory是Executors類中的私有靜態內部類，實現了ThreadFactory接口。ThreadFactory接口定義了newThread(Runnable r)方法用于創建新線程。

(3) 實現過程

• 初始化：調用privilegedThreadFactory方法時，返回一個新的PrivilegedThreadFactory實例。
• 線程創建：當使用此工廠創建線程時，它調用newThread(Runnable r)方法。
• 特權訪問：在newThread(Runnable r)方法實現中，使用AccessController.doPrivileged方法確保新創建的線程具有特權訪問權限。
• 上下文繼承：新線程通常繼承創建它的線程的上下文，包括類加載器和其他設置。

(4) 示例

雖然我們無法查看privilegedThreadFactory的精確實現，但我們可以提供一個示例實現來演示如何創建特權線程：

public class PrivilegedThreadFactory implements ThreadFactory {
    @Override
    public Thread newThread(Runnable r) {
        return AccessController.doPrivileged(new PrivilegedAction<>() {
            @Override
            public Thread run() {
                return new Thread(r);
            }
        });
    }
}

在這個示例中，PrivilegedAction是一個實現PrivilegedAction接口的匿名類，其中run方法創建一個新線程。AccessController.doPrivileged方法執行一個特權操作，以確保線程創建過程具有必要的權限。

(5) 特性

• 特權訪問：使用privilegedThreadFactory創建的線程可以訪問敏感系統資源，適用于需要此類訪問的應用程序。
• 簡化安全：使用AccessController.doPrivileged確保線程在執行期間被授予適當的安全權限。
• 上下文繼承：新線程繼承其父線程的上下文，包括類加載器和其他安全設置。

(6) 使用場景

• 訪問系統資源：適用于需要線程具有更高權限以訪問系統屬性或執行文件 I/O 操作的應用程序。
• 安全敏感操作：確保執行安全敏感操作的線程具有必要的權限，以避免安全異常。

8. defaultThreadFactory()

defaultThreadFactory是 Java java.util.concurrent包中Executors類的靜態工廠方法。此方法創建一個默認線程工廠，生成具有標準屬性的線程，沒有特殊權限。

(1) 實現原理

• 標準線程創建：線程工廠生成具有默認屬性的線程。
• 線程命名：創建的線程具有默認名稱前綴，通常形式為“pool-x-thread-y”，其中 x 和 y 是數字。
• 線程優先級：線程優先級設置為Thread.NORM_PRIORITY，這是 Java 線程的默認優先級。
• 非守護線程：創建的線程是非守護線程，這意味著它們的存在將阻止 JVM 退出。

(2) 源代碼分析

defaultThreadFactory方法的詳細實現未完全暴露，但我們可以從ThreadFactory接口和一些可用的源代碼片段推斷其行為。

以下是defaultThreadFactory方法的典型調用：

public static ThreadFactory defaultThreadFactory() {
    return new DefaultThreadFactory();
}

DefaultThreadFactory是Executors類中的私有靜態內部類，實現了ThreadFactory接口。ThreadFactory接口定義了newThread(Runnable r)方法用于創建新線程。

(3) 實現過程

• 初始化：調用defaultThreadFactory方法時，返回一個新的DefaultThreadFactory實例。
• 線程創建：當使用此工廠創建線程時，它調用newThread(Runnable r)方法。
• 線程命名：newThread(Runnable r)方法創建一個新的Thread對象并設置默認線程名稱。
• 線程組分配：新線程被分配到一個默認線程組。
• 線程優先級和守護狀態：線程優先級設置為默認值，如果初始為守護線程，則將其設置為非守護線程。

(4) 示例

雖然無法看到defaultThreadFactory的精確實現，但我們可以提供一個示例實現來演示如何創建具有默認屬性的線程

public class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s!= null)? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                     poolNumber.getAndIncrement() +
                     "-thread-";
    }

    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority()!= Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

在這個示例中，DefaultThreadFactory使用AtomicInteger確保池和線程編號的唯一性。創建的線程名稱具有前綴“pool-x-thread-y”，其中 x 和 y 是遞增的數字。線程是非守護的，其優先級設置為Thread.NORM_PRIORITY。

(5) 特性

• 標準線程屬性：使用defaultThreadFactory創建的線程具有標準的 Java 線程屬性。
• 非特殊用途：此線程工廠適用于不需要特殊權限的應用程序。
• 非守護線程：這些線程的存在將阻止 JVM 退出，直到所有非守護線程完成執行。

(6) 使用場景

• 標準應用程序：適用于大多數需要具有默認屬性線程的標準應用程序。
• ExecutorService 實現：在不需要特殊線程屬性時，通常用作ExecutorService實現的默認選擇。

9. unconfigurableExecutorService(ExecutorService executor)

unconfigurableExecutorService方法在 Java java.util.concurrent包的Executors類中，用于創建一個圍繞ExecutorService的不可配置包裝器。這意味著一旦包裝的ExecutorService被創建，其配置就不能被更改，例如修改池大小或任務隊列。

(1) 實現原理

• 封裝：將現有的ExecutorService包裝在一個不可配置的代理中。
• 不可變配置：任何更改配置的方法調用，如shutdown、shutdownNow、setCorePoolSize等，都將拋出UnsupportedOperationException。
• 委托：其他方法調用被委托給原始的ExecutorService。

(2) 源代碼分析

unconfigurableExecutorService方法的詳細實現未完全暴露，因為它是Executors類的私有方法的一部分。然而，我們可以根據ExecutorService接口和代理機制推斷其行為。

以下是unconfigurableExecutorService方法的典型調用：

public static ExecutorService unconfigurableExecutorService(ExecutorService executor) {
    return new FinalizableDelegatedExecutorService(executor);
}

FinalizableDelegatedExecutorService是Executors類中的私有靜態內部類，實現了ExecutorService接口，并將方法調用委托給另一個ExecutorService。

(3) 實現過程

• 初始化：調用unconfigurableExecutorService方法時，返回一個新的FinalizableDelegatedExecutorService實例，該實例將原始的ExecutorService作為參數。
• 方法攔截：對FinalizableDelegatedExecutorService方法的調用首先被攔截。
• 配置修改攔截：如果方法是用于修改配置的，如shutdown或shutdownNow，則拋出UnsupportedOperationException。
• 委托其他調用：不涉及配置修改的調用，如submit或execute，被委托給原始的ExecutorService。

(4) 示例

以下是一個示例實現，演示如何創建一個不可配置的ExecutorService代理：

public class UnconfigurableExecutorService implements ExecutorService {
    private final ExecutorService executor;

    public UnconfigurableExecutorService(ExecutorService executor) {
        this.executor = executor;
    }

    @Override
    public void shutdown() {
        throw new UnsupportedOperationException("Shutdown not allowed");
    }

    @Override
    public List<Runnable> shutdownNow() {
        throw new UnsupportedOperationException("Shutdown not allowed");
    }

    @Override
    public boolean isShutdown() {
        return executor.isShutdown();
    }

    @Override
    public boolean isTerminated() {
        return executor.isTerminated();
    }

    @Override
    public void execute(Runnable command) {
        executor.execute(command);
    }
}

在這個示例中，UnconfigurableExecutorService攔截shutdown和shutdownNow方法并拋出UnsupportedOperationException。其他方法直接委托給原始的ExecutorService。

(5) 特性

• 不可變配置：創建的ExecutorService包裝器確保線程池的配置不能被外部更改。
• 共享環境中的安全性：有助于防止意外更改線程池的狀態，提高多線程環境中的安全性。
• 維護原始行為：其他方法保留原始ExecutorService的行為。

(6) 使用場景

• 共享線程池：適用于多個組件共享同一個線程池的情況，防止一個組件意外修改配置。
• 受控環境：在需要線程池配置保持一致且不可更改的環境中很有用。