在前面的所有示例中，由新的線程（由其Runnable對象定義）和線程本身（由Thread對象定義）完成的任務之間存在緊密的聯系，這適用于小型應用程序，但在大型應用程序中，將線程管理和創建與應用程序的其余部分分開是有意義的，封裝這些函數的對象稱為執行器，以下小節詳細描述了執行器。

執行器接口定義三個執行器對象類型。

線程池是最常見的執行器實現類型。

Fork/Join是一個利用多個處理器的框架（JDK 7中的新增功能）。

java.util.concurrent包定義了三個執行器接口：

Executor，一個支持啟動新任務的簡單接口。

ExecutorService，Executor的子接口，它添加了有助于管理生命周期的功能，包括單個任務和執行器本身。

ScheduledExecutorService，ExecutorService的子接口，支持將來和/或定期執行任務。

通常，引用執行器對象的變量被聲明為這三種接口類型之一，而不是執行器類類型。

Executor接口提供單個方法execute，旨在成為常見線程創建語法的替代方法，如果r是Runnable對象，并且e是Executor對象，則可以替換

(new Thread(r)).start();

為

e.execute(r);

但是，execute的定義不太具體，低級別語法創建一個新線程并立即啟動它，根據Executor實現，execute可能會做同樣的事情，但更有可能使用現有的工作線程來運行r，或者將r放在隊列中以等待工作線程變為可用（我們將在線程池的部分中描述工作線程）。

java.util.concurrent中的執行器實現旨在充分利用更高級的ExecutorService和ScheduledExecutorService接口，盡管它們也可以與基本Executor接口一起使用。

ExecutorService接口使用類似但更通用的submit方法補充execute，與execute一樣，submit接受Runnable對象，但也接受Callable對象，這允許任務返回一個值。submit方法返回一個Future對象，該對象用于檢索Callable返回值并管理Callable和Runnable任務的狀態。

ExecutorService還提供了提交大量Callable對象的方法，最后，ExecutorService提供了許多用于管理執行器關閉的方法，為了支持立即關閉，任務應該正確處理中斷。

ScheduledExecutorService接口使用schedule補充其父級ExecutorService的方法，在指定的延遲后執行Runnable或Callable任務，此外，接口定義了scheduleAtFixedRate和scheduleWithFixedDelay，它們以定義的間隔重復執行指定的任務。

java.util.concurrent中的大多數執行器實現都使用由工作線程組成的線程池，這種線程與它執行的Runnable和Callable任務分開存在，通常用于執行多個任務。

使用工作線程可以最小化由于創建線程而帶來的開銷，線程對象使用大量內存，在大型應用程序中，分配和釋放許多線程對象會產生大量的內存管理開銷。

一種常見類型的線程池是固定線程池，這種類型的池始終具有指定數量的線程，如果一個線程在它仍在使用時以某種方式被終止，它將自動被一個新線程替換，任務通過內部隊列提交到池中，當活動任務多于線程時，該隊列將保存額外的任務。

固定線程池的一個重要優點是使用它的應用程序可以優雅地降級，要理解這一點，請考慮一個Web服務器應用程序，其中每個HTTP請求都由一個多帶帶的線程處理。如果應用程序只是為每個新的HTTP請求創建一個新線程，并且系統接收的請求數量超過了可以立即處理的數量，當所有這些線程的開銷超過系統容量時，應用程序將突然停止響應所有請求。由于可以創建的線程數量有限制，應用程序不會像HTTP請求進入時那樣快地為它們提供服務，而是以系統能夠承受的最快速度為它們提供服務。

創建使用固定線程池的執行器的一種簡單方法是在java.util.concurrent.Executors中調用newFixedThreadPool工廠方法，該類還提供以下工廠方法：

newCachedThreadPool方法使用可擴展線程池創建執行器，此執行器適用于啟動許多短期任務的應用程序。

newSingleThreadExecutor方法創建一次執行單個任務的執行器。

有幾個工廠方法是上述執行器的ScheduledExecutorService版本。

如果上述工廠方法提供的執行器均無法滿足你的需求，構造java.util.concurrent.ThreadPoolExecutor或java.util.concurrent.ScheduledThreadPoolExecutor的實例將為你提供額外選項。

fork/join框架是ExecutorService接口的一個實現，可幫助你利用多個處理器，它專為可以遞歸分解成小塊的工作而設計，目標是使用所有可用的處理能力來增強應用程序的性能。

與任何ExecutorService實現一樣，fork/join框架將任務分配給線程池中的工作線程，fork/join框架是不同的，因為它使用了工作竊取算法，沒有事情可做的工作線程可以從仍然忙碌的其他線程中竊取任務。

fork/join框架的中心是ForkJoinPool類，它是AbstractExecutorService類的擴展，ForkJoinPool實現了核心工作竊取算法，可以執行ForkJoinTask進程。

使用fork/join框架的第一步是編寫執行工作片段的代碼，你的代碼應類似于以下偽代碼：

if (我的工作部分足夠小)
  直接做這項工作
else
  把我的工作分成兩塊
  調用這兩塊并等待結果

將此代碼包裝在ForkJoinTask子類中，通常使用其更專業的類型之一，RecursiveTask（可以返回結果）或RecursiveAction。

在ForkJoinTask子類準備就緒后，創建表示要完成的所有工作的對象，并將其傳遞給ForkJoinPool實例的invoke()方法。

為了幫助你了解fork/join框架的工作原理，請考慮以下示例，假設你想模糊圖像，原始源圖像由整數數組表示，其中每個整數包含單個像素的顏色值，模糊的目標圖像也由與源相同大小的整數數組表示。

通過一次一個像素地處理源數組來完成模糊，將每個像素與其周圍像素進行平均(對紅色、綠色和藍色組件進行平均)，并將結果放置在目標數組中，由于圖像是大型數組，因此此過程可能需要很長時間，通過使用fork/join框架實現的算法，你可以利用多處理器系統上的并發處理，這是一個可能的實現：

public class ForkBlur extends RecursiveAction {
    private int[] mSource;
    private int mStart;
    private int mLength;
    private int[] mDestination;
  
    // Processing window size; should be odd.
    private int mBlurWidth = 15;
  
    public ForkBlur(int[] src, int start, int length, int[] dst) {
        mSource = src;
        mStart = start;
        mLength = length;
        mDestination = dst;
    }

    protected void computeDirectly() {
        int sidePixels = (mBlurWidth - 1) / 2;
        for (int index = mStart; index < mStart + mLength; index++) {
            // Calculate average.
            float rt = 0, gt = 0, bt = 0;
            for (int mi = -sidePixels; mi <= sidePixels; mi++) {
                int mindex = Math.min(Math.max(mi + index, 0),
                                    mSource.length - 1);
                int pixel = mSource[mindex];
                rt += (float)((pixel & 0x00ff0000) >> 16)
                      / mBlurWidth;
                gt += (float)((pixel & 0x0000ff00) >>  8)
                      / mBlurWidth;
                bt += (float)((pixel & 0x000000ff) >>  0)
                      / mBlurWidth;
            }
          
            // Reassemble destination pixel.
            int dpixel = (0xff000000     ) |
                   (((int)rt) << 16) |
                   (((int)gt) <<  8) |
                   (((int)bt) <<  0);
            mDestination[index] = dpixel;
        }
    }
  
  ...

現在，你實現抽象的compute()方法，該方法可以直接執行模糊或將其拆分為兩個較小的任務，簡單的數組長度閾值有助于確定是執行還是拆分工作。

protected static int sThreshold = 100000;

protected void compute() {
    if (mLength < sThreshold) {
        computeDirectly();
        return;
    }
    
    int split = mLength / 2;
    
    invokeAll(new ForkBlur(mSource, mStart, split, mDestination),
              new ForkBlur(mSource, mStart + split, mLength - split,
                           mDestination));
}

如果以前的方法在RecursiveAction類的子類中，那么將任務設置為在ForkJoinPool中運行是很簡單的，涉及以下步驟：

創建一個代表要完成的所有工作的任務。

// source image pixels are in src
// destination image pixels are in dst
ForkBlur fb = new ForkBlur(src, 0, src.length, dst);

創建將運行任務的ForkJoinPool。

ForkJoinPool pool = new ForkJoinPool();

運行任務。

pool.invoke(fb);

有關完整源代碼（包括創建目標圖像文件的一些額外代碼），請參閱ForkBlur示例。

除了使用fork/join框架來實現在多處理器系統上同時執行任務的自定義算法（例如ForkBlur.java示例），Java SE中已經使用fork/join框架實現了一些通常有用的功能，在Java SE 8中引入的一種這樣的實現被java.util.Arrays類用于其parallelSort()方法，這些方法類似于sort()，但通過fork/join框架利用并發性。在多處理器系統上運行時，大型數組的并行排序比順序排序更快，但是，這些方法如何利用fork/join框架超出了Java教程的范圍，有關此信息，請參閱Java API文檔。

fork/join框架的另一個實現由java.util.streams包中的方法使用，這是Project Lambda計劃用于Java SE 8版本的一部分，有關更多信息，請參閱Lambda表達式部分。