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

執(zhí)行器接口定義三個執(zhí)行器對象類型。

線程池是最常見的執(zhí)行器實(shí)現(xiàn)類型。

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

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

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

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

ScheduledExecutorService，ExecutorService的子接口，支持將來和/或定期執(zhí)行任務(wù)。

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

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

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

為

e.execute(r);

但是，execute的定義不太具體，低級別語法創(chuàng)建一個新線程并立即啟動它，根據(jù)Executor實(shí)現(xiàn)，execute可能會做同樣的事情，但更有可能使用現(xiàn)有的工作線程來運(yùn)行r，或者將r放在隊(duì)列中以等待工作線程變?yōu)榭捎茫ㄎ覀儗⒃诰€程池的部分中描述工作線程）。

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

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

ExecutorService還提供了提交大量Callable對象的方法，最后，ExecutorService提供了許多用于管理執(zhí)行器關(guān)閉的方法，為了支持立即關(guān)閉，任務(wù)應(yīng)該正確處理中斷。

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

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

使用工作線程可以最小化由于創(chuàng)建線程而帶來的開銷，線程對象使用大量內(nèi)存，在大型應(yīng)用程序中，分配和釋放許多線程對象會產(chǎn)生大量的內(nèi)存管理開銷。

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

固定線程池的一個重要優(yōu)點(diǎn)是使用它的應(yīng)用程序可以優(yōu)雅地降級，要理解這一點(diǎn)，請考慮一個Web服務(wù)器應(yīng)用程序，其中每個HTTP請求都由一個多帶帶的線程處理。如果應(yīng)用程序只是為每個新的HTTP請求創(chuàng)建一個新線程，并且系統(tǒng)接收的請求數(shù)量超過了可以立即處理的數(shù)量，當(dāng)所有這些線程的開銷超過系統(tǒng)容量時，應(yīng)用程序?qū)⑼蝗煌Ｖ鬼憫?yīng)所有請求。由于可以創(chuàng)建的線程數(shù)量有限制，應(yīng)用程序不會像HTTP請求進(jìn)入時那樣快地為它們提供服務(wù)，而是以系統(tǒng)能夠承受的最快速度為它們提供服務(wù)。

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

newCachedThreadPool方法使用可擴(kuò)展線程池創(chuàng)建執(zhí)行器，此執(zhí)行器適用于啟動許多短期任務(wù)的應(yīng)用程序。

newSingleThreadExecutor方法創(chuàng)建一次執(zhí)行單個任務(wù)的執(zhí)行器。

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

如果上述工廠方法提供的執(zhí)行器均無法滿足你的需求，構(gòu)造java.util.concurrent.ThreadPoolExecutor或java.util.concurrent.ScheduledThreadPoolExecutor的實(shí)例將為你提供額外選項(xiàng)。

fork/join框架是ExecutorService接口的一個實(shí)現(xiàn)，可幫助你利用多個處理器，它專為可以遞歸分解成小塊的工作而設(shè)計，目標(biāo)是使用所有可用的處理能力來增強(qiáng)應(yīng)用程序的性能。

與任何ExecutorService實(shí)現(xiàn)一樣，fork/join框架將任務(wù)分配給線程池中的工作線程，fork/join框架是不同的，因?yàn)樗褂昧斯ぷ鞲`取算法，沒有事情可做的工作線程可以從仍然忙碌的其他線程中竊取任務(wù)。

fork/join框架的中心是ForkJoinPool類，它是AbstractExecutorService類的擴(kuò)展，ForkJoinPool實(shí)現(xiàn)了核心工作竊取算法，可以執(zhí)行ForkJoinTask進(jìn)程。

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

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

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

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

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

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

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;
        }
    }
  
  ...

現(xiàn)在，你實(shí)現(xiàn)抽象的compute()方法，該方法可以直接執(zhí)行模糊或?qū)⑵洳鸱譃閮蓚€較小的任務(wù)，簡單的數(shù)組長度閾值有助于確定是執(zhí)行還是拆分工作。

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類的子類中，那么將任務(wù)設(shè)置為在ForkJoinPool中運(yùn)行是很簡單的，涉及以下步驟：

創(chuàng)建一個代表要完成的所有工作的任務(wù)。

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

創(chuàng)建將運(yùn)行任務(wù)的ForkJoinPool。

ForkJoinPool pool = new ForkJoinPool();

運(yùn)行任務(wù)。

pool.invoke(fb);

有關(guān)完整源代碼（包括創(chuàng)建目標(biāo)圖像文件的一些額外代碼），請參閱ForkBlur示例。

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

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