在Java并發(fā)編程中，Executor和Executors是兩個密切相關但功能不同的類或接口，它們都與線程池管理和任務執(zhí)行相關。理解這兩者的區(qū)別對正確使用Java并發(fā)API非常重要。

1. Executor 的定義與功能

1.1 Executor 接口

Executor 是 Java 并發(fā)框架中的一個核心接口，它提供了一種將任務的提交與任務的執(zhí)行解耦的機制。換句話說，Executor接口的設計目標是將“任務的執(zhí)行”這一行為抽象出來，使得任務的提交者不必關心任務是如何執(zhí)行的（如是否在新的線程中執(zhí)行、是否在某個線程池中執(zhí)行等）。

public interface Executor {
    void execute(Runnable command);
}

execute(Runnable command) 方法：這是 Executor 接口中唯一的方法，它接受一個實現了 Runnable 接口的任務，并安排該任務的執(zhí)行。具體如何執(zhí)行這個任務，由實現 Executor 接口的類決定。

1.2 Executor 接口的設計目的

Executor接口的主要設計目的是簡化并發(fā)任務的執(zhí)行過程，提供了一種統(tǒng)一的方式來提交任務，而不需要開發(fā)者顯式地創(chuàng)建和管理線程。通過這一接口，開發(fā)者可以將任務的執(zhí)行策略（如線程池、異步執(zhí)行等）與業(yè)務邏輯分離，使得代碼更簡潔、可維護性更高。

2. Executors 的定義與功能

2.1 Executors 類

Executors 是一個實用工具類，它包含了一些靜態(tài)工廠方法，用于創(chuàng)建 Executor、ExecutorService、ScheduledExecutorService 等的常用實現。這些實現通常與線程池相關，因此 Executors 類在實際開發(fā)中非常常用。

public class Executors {
    // 創(chuàng)建一個單線程執(zhí)行器
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

    // 創(chuàng)建一個固定線程數的線程池
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

    // 創(chuàng)建一個可以根據需要擴展的線程池
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

    // 其他工廠方法...
}

2.2 Executors 類的常用方法

Executors 類提供了多種創(chuàng)建線程池的方法，每種方法返回的都是 ExecutorService 的不同實現，這些實現適合不同的并發(fā)場景：

• newFixedThreadPool(int nThreads)：創(chuàng)建一個固定大小的線程池。這個線程池中的線程數量是固定的，無論有多少任務提交到線程池中，線程池中同時運行的線程數量不會超過指定的大小。適用于處理穩(wěn)定數量的并發(fā)任務。

• newCachedThreadPool()：創(chuàng)建一個可緩存的線程池。這個線程池會根據需要創(chuàng)建新線程，如果線程空閑超過60秒則會被回收，因此在大量短期異步任務的場景中非常有用。

• newSingleThreadExecutor()：創(chuàng)建一個單線程執(zhí)行器。這個執(zhí)行器確保所有任務在一個線程中按順序執(zhí)行，適用于需要順序執(zhí)行任務的場景。

• newScheduledThreadPool(int corePoolSize)：創(chuàng)建一個定時線程池。該線程池支持任務調度和周期性執(zhí)行，適用于需要定期執(zhí)行任務的場景。

3. Executor 與 Executors 的區(qū)別

3.1 接口與工具類的區(qū)別

• Executor 是接口：Executor 是一個接口，定義了一個任務執(zhí)行的標準方法 execute(Runnable command)。它提供了一個抽象層，使得任務的提交者無需關心任務是如何被執(zhí)行的。

• Executors 是工具類：Executors 是一個工具類，提供了創(chuàng)建各種 Executor、ExecutorService 實現的靜態(tài)工廠方法。它簡化了線程池的創(chuàng)建過程，使得開發(fā)者能夠方便地獲得適合自己應用場景的線程池實現。

3.2 關注點的區(qū)別

• Executor 關注的是任務的執(zhí)行：Executor 關注如何執(zhí)行提交的任務，定義了任務執(zhí)行的標準接口。它是一種行為規(guī)范，使得不同的執(zhí)行器可以被替換而不改變代碼的行為。

• Executors 關注的是如何創(chuàng)建 Executor：Executors 關注的是如何創(chuàng)建符合特定需求的線程池或任務執(zhí)行器。它提供了多種預定義的 Executor 和 ExecutorService 實現，幫助開發(fā)者根據不同的并發(fā)需求選擇合適的執(zhí)行策略。

3.3 使用場景的區(qū)別

• Executor 的使用場景：Executor 通常用于需要自定義任務執(zhí)行邏輯的場景，例如自定義任務調度策略、管理任務隊列等。開發(fā)者可以實現 Executor 接口，定義自己的任務執(zhí)行器。

• Executors 的使用場景：Executors 通常用于創(chuàng)建標準的線程池或執(zhí)行器，適合常見的并發(fā)任務執(zhí)行需求。通過使用 Executors 提供的工廠方法，開發(fā)者可以快速創(chuàng)建和使用線程池，而無需關心底層實現細節(jié)。

4. 實際使用中的示例

4.1 使用 Executor

假設我們有一個簡單的任務調度系統(tǒng)，我們可以使用 Executor 接口來抽象任務的執(zhí)行過程：

public class SimpleExecutor implements Executor {
    @Override
    public void execute(Runnable command) {
        new Thread(command).start();
    }
}

這個 SimpleExecutor 類實現了 Executor 接口，它在每次接收到任務時都會創(chuàng)建一個新線程來執(zhí)行任務。這種實現非常簡單，但在實際應用中通常會使用更復雜的執(zhí)行器，例如線程池。

4.2 使用 Executors

通過 Executors 工具類，我們可以很方便地創(chuàng)建一個固定大小的線程池，并提交任務：

public class ExecutorExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            executor.execute(new RunnableTask(i));
        }

        executor.shutdown();
    }
}

class RunnableTask implements Runnable {
    private int taskId;

    public RunnableTask(int id) {
        this.taskId = id;
    }

    @Override
    public void run() {
        System.out.println("Executing task " + taskId + " by " + Thread.currentThread().getName());
    }
}

在這個示例中，我們使用 Executors.newFixedThreadPool(5) 創(chuàng)建了一個固定大小為5的線程池，然后提交了10個任務給線程池執(zhí)行。線程池將自動管理這些任務的執(zhí)行，并復用線程來處理任務。

5. 總結

在Java并發(fā)編程中，Executor和Executors雖然名稱相似，但它們有著截然不同的職責和用途：

• Executor 是一個接口，定義了任務執(zhí)行的標準方法，它是并發(fā)編程中任務執(zhí)行的核心抽象。Executor 讓任務的提交者不需要關心任務的具體執(zhí)行方式，從而實現任務執(zhí)行與業(yè)務邏輯的解耦。

• Executors 是一個工具類，提供了多種工廠方法來創(chuàng)建不同類型的 Executor 和 ExecutorService 實現。通過使用 Executors 提供的工廠方法，開發(fā)者可以輕松創(chuàng)建和管理線程池，以適應各種并發(fā)編程需求。

到此這篇關于Java中Executor和Executors的區(qū)別小結的文章就介紹到這了,更多相關Java Executor Executors內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！ 

最新評論