2. 程式人生 > >Java併發程式設計(5)-Executor執行緒排程框架解讀

Java併發程式設計(5)-Executor執行緒排程框架解讀

阿新 • • 發佈：2018-11-15

文章目錄

更多關於Java併發程式設計的文章請點選這裡：Java併發程式設計實踐(0)-目錄頁

Executor框架是在JDK5之後引入的一種執行緒排程類的集合，這些類的集合可以被統稱為執行緒排程框架，本文將介紹Executor執行緒排程框架、各類執行緒池、Runnable和Callable< T >任務排程介面以及如何使用執行緒排程框架構造一個併發程式，最後介紹一下ExecutorCompletionService。
本文總結自《Java併發程式設計實踐》第六章 任務執行 ，以及一些相關部落格。

一、Executor執行緒排程框架

1.1、什麼是執行緒排程框架

Executor框架是在JDK5之後引入的一種執行緒排程類的集合，這些類的集合可以被統稱為執行緒排程框架，在這個框架體系中，任務的執行最小單元不是執行緒（Thread），而是任務(Task)；而Executor可視為任務的執行器，它的作用是執行任務，進行任務的排程。常用的執行緒排程類和介面有:
Executors工廠類、Executor介面、ExecutorService介面、ExecutorCompletionService類、Runnable任務介面、Callable< T >響應式任務介面、Future< T >任務狀態類、newFixedThreadPool定長執行緒池、newCachedThreadPool可快取執行緒池、newSingleThreadExecutor單一執行緒池、newScheduledThreadPool可排程執行緒池。以上可簡單地用結構圖表示：
在這裡插入圖片描述

1.2、Executors

提供了一系列靜態工廠方法用於建立各種執行緒池,可返回一個Executor物件或者ExecutorService物件，用以執行任務。

1.3、Executor

一個介面，其定義了一個接收Runnable物件的方法executor(Runnable command),用以執行Runabl任務。

1.4、ExecutorService

繼承於Executor，是一個比Executor使用更廣泛的子類介面，其提供了生命週期管理的方法，以及可跟蹤一個或多個非同步任務執行狀況返回Future的方法。

1.5、ScheduledThreadPoolExecutor

ScheduledExecutorService的實現，一個可定時排程任務的執行緒池，由Executors.newScheduledThreadPool返回，可用來代替Timer進行定時任務排程。

二、各類執行緒池

2.1、newFixedThreadPool

建立可重用且固定執行緒數的執行緒池，如果執行緒池中的所有執行緒都處於活動狀態，此時再提交任務就在佇列中等待，直到有可用執行緒；如果執行緒池中的某個執行緒由於異常而結束時，執行緒池就會再補充一條新執行緒。原理是有界的阻塞佇列。



public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  //使用一個基於FIFO排序的阻塞佇列，在所有corePoolSize執行緒都忙時新任務將在佇列中等待
                                  new LinkedBlockingQueue<Runnable>());
}

2.2、newCachedThreadPool

建立可快取的執行緒池，如果執行緒池中的執行緒在60秒未被使用就將被移除，在執行新的任務時，當執行緒池中有之前建立的可用執行緒就重用可用執行緒，否則就新建一條執行緒。



public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  //使用同步佇列，將任務直接提交給執行緒
                                  new SynchronousQueue<Runnable>());
}

2.3、newScheduledThreadPool

建立一個可延遲執行或定期執行的執行緒池。

public class HeartBeat {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);
        Runnable task = new Runnable() {
            public void run() {
                System.out.println("HeartBeat.........................");
            }
        };
        executor.scheduleAtFixedRate(task,5,3, TimeUnit.SECONDS);   //5秒後第一次執行，之後每隔3秒執行一次
    }
}

2.4、newSingleThreadExecutor

建立一個單執行緒的Executor，如果該執行緒因為異常而結束就新建一條執行緒來繼續執行後續的任務。

public static ExecutorService newSingleThreadExecutor() {
   return new FinalizableDelegatedExecutorService
                     //corePoolSize和maximumPoolSize都等於，表示固定執行緒池大小為1
                        (new ThreadPoolExecutor(1, 1,
                                                0L, TimeUnit.MILLISECONDS,
                                                new LinkedBlockingQueue<Runnable>()));
}

三、Runnable和Callable< T >任務排程介面

3.1、Runnable介面

每個任務排程介面都是另起一個執行緒作業，其中Runnable介面中的run方法不能返回引數，所以也稱為無響應任務介面，結合上面的內容，我們來看以下簡單的使用：

@Test
        public void demo1(){
            //使用Executors工廠類建立含10個執行緒的Executor執行器
            Executor executor = Executors.newFixedThreadPool(10);
            //建立一個無響應式任務
            Runnable task = new Runnable(){
                public void run(){
                    //具體任務實現
                    System.out.println("任務已執行");
                }
            };
            //執行任務
            executor.execute(task);
        }

結果：
在這裡插入圖片描述

3.2、Callable< T >介面和Future介面

Callable< T >介面用以實現有返回值的任務，需要注意的是，應該宣告ExecutorService 介面型別來提交callable任務，並且獲得了當前任務的狀態宣告Future物件，通過它獲取到任務返回的值，如下：

 @Test
    public void demo2() throws ExecutionException, InterruptedException {
        //使用Executors工廠類建立含10個執行緒的ExecutorService執行器
        ExecutorService executor = Executors.newFixedThreadPool(10);
        //建立一個響應式任務
        Callable<Integer> task = new Callable<Integer>(){
            public Integer call(){
                //執行有返回值的任務
                int i = 0;
                return ++i;
            }
        };
        //提交任務，獲得任務狀態類Futrue
        Future<Integer> future = executor.submit(task);
        //獲得Future中的任務返回的響應值
        Integer response = future.get();
        System.out.println("任務執行，並返回了："+response);
    }

在這裡插入圖片描述

四、使用執行緒排程框架構造一個併發程式

4.1、單執行緒模式

結合上述知識，我們可以構造一個簡單的併發程式了。設想這樣一個情景：小明早上起床了，他去煮水。。。
如果是單執行緒程式，比如只用main（）方法執行，小明只能等水煮完了，才能去看書，聽歌，如以下程式碼：

  public static void main(String[] args) {
            //第一個迴圈執行10次,其中i表示小明正在煮水的進度
        for (int i = 0; i < 10; i++) {
            System.out.println("煮水中："+i);
        }

        //第二個迴圈，表示看書
        for (int i = 0; i < 5; i++) {
            System.out.println("看書中："+i);
        }

        //第三個迴圈，表示聽音樂
        for (int i = 0; i < 5; i++) {
            System.out.println("聽歌中: "+i);
        }

        //...
    }

在這裡插入圖片描述

4.2、多執行緒排程模式-使用Runnable

上面的就是典型的單執行緒模式了，所有工作都要從頭執行到尾，可是在現實中，小明可以變煮水邊看書邊聽歌，這樣就不會浪費時間，所以這裡就要開啟至少3個執行緒去做這3件事情：

@Test
   public void demo3() throws ExecutionException, InterruptedException {
       //使用Executors工廠類建立含3個執行緒的ExecutorService執行器
       ExecutorService executor = Executors.newFixedThreadPool(3);

       //建立一個任務1-煮水
       Runnable task1 = new Runnable(){
           public void run(){
               for (int i = 0; i < 10; i++) {
                   System.out.println(Thread.currentThread().getName()+"煮水中： "+i);
               }
           }
       };

       //建立一個任務2-看書
       Runnable task2 = new Runnable(){
           public void run(){
               for (int i = 0; i < 5; i++) {
                   System.out.println(Thread.currentThread().getName()+"看書中： "+i);
               }
           }
       };

       //建立一個任務3-聽歌
       Runnable task3 = new Runnable(){
           public void run(){
               for (int i = 0; i < 5; i++) {
                   System.out.println(Thread.currentThread().getName()+"聽歌中： "+i);
               }
           }
       };


       //提交3個任務給執行緒池去分配執行緒執行
       executor.execute(task1);
       executor.execute(task2);
       executor.execute(task3);

   }

在這裡插入圖片描述

可以看出，Executor執行緒排程框架分配了3個執行緒去分別執行了這3個任務，使得程式變成了併發的，提高了工作的效率。

4.3、多執行緒排程模式-使用Callable< T >

當然，我們也可以使用Callable< T >任務介面來完成上述的多執行緒排程例子：

 @Test
    public void fun14() throws ExecutionException, InterruptedException {
        //使用Executors工廠類建立含3個執行緒的ExecutorService執行器
        ExecutorService executor = Executors.newFixedThreadPool(3);

        //建立一個任務1-煮水
        Callable<Integer> task1 = new Callable<Integer>(){
            public Integer call(){
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"煮水中 ："+i);
                }
                return null;
            }
        };


        //建立一個任務2-看書
        Callable<Integer> task2 = new Callable<Integer>(){

            @Override
            public Integer call(){
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName()+"看書中 ："+i);
                }
                    return null;
            }

        };

        //建立一個任務3-聽歌
        Callable<Integer> task3 = new Callable<Integer>(){

            @Override
            public Integer call(){
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName()+"聽歌中 ："+i);
                }
                return null;
            }

        };

        //提交3個任務給執行緒池去分配執行緒執行並獲得執行緒狀態物件
        Future<Integer> future1 = executor.submit(task1);
        Future<Integer> future2 = executor.submit(task2);
        Future<Integer> future3 = executor.submit(task3);
    }

五、ExecutorCompletionService

實現了CompletionService，將執行完成的任務放到阻塞佇列中，通過take或poll方法來獲得執行結果Future，然後呼叫Future的get方法即可獲得響應的結果了。

@Test
    public void demo4() throws InterruptedException, ExecutionException {
        CopyOnWriteArrayList<Object> list = new CopyOnWriteArrayList<>();
            //獲得含有快取執行緒池的Executor
        ExecutorService executor = Executors.newCachedThreadPool();
        //建立一個ExecutorCompletionService,將executor交給它管理
        ExecutorCompletionService completionService = new ExecutorCompletionService(executor);
        for (int i = 0; i < 10; i++) {
            int result = i;
            //建立一個響應式任務，迴圈執行10次
            Callable<Object> task = new Callable<Object>(){
                public Object call() throws InterruptedException {
                    return result;
                }
            };
            //提交任務
            completionService.submit(task);
            //將結果放入集合中
            Object o = completionService.take().get();
            list.add((Integer)o);
        }

        //將集合遍歷
        for (Object o : list) {
            System.out.print((Integer)o+"\t");
        }


    }

在這裡插入圖片描述

六、ExecutorService的生命週期管理

ExecutorService繼承自Executor介面，定義了一些生命週期的方法：

  public interface ExecutorService extends Executor {   
    void shutdown();   
    List<Runnable> shutdownNow();   
    boolean isShutdown();   
    boolean isTerminated();   
    boolean awaitTermination(long timeout, TimeUnit unit)   
            throws InterruptedException;   
    }

6.1、shutdown方法

這個方法用於會強制關閉ExecutorService，它將取消所有執行中的任務和在工作佇列中等待的任務。

6.2、shutdownNow方法

這個方法會強制關閉ExecutorService，它將取消所有執行中的任務和在工作佇列中等待的任務，這個方法返回一個List列表，列表中返回的是等待在工作佇列中的任務。

6.3、isShutdown方法

這個方法在ExecutorService關閉後返回true，否則返回false。

6.4、isTerminated方法

這個方法會校驗ExecutorService當前的狀態是否為“TERMINATED”即關閉狀態，當為關閉狀態時時返回true否則返回false。

6.5、awaitTermination方法

這個方法有兩個引數，一個是timeout即超時時間，另一個是unit即時間單位。這個方法會使執行緒等待timeout時長，當超過timeout時間後，會監測ExecutorService是否已經關閉，若關閉則返回true，否則返回false。

相關推薦

Java併發程式設計(5)-Executor執行緒排程框架解讀

文章目錄 一、Executor執行緒排程框架 1.1、什麼是執行緒排程框架 1.2、Executors 1.3、Executor 1.4、ExecutorService 1

【java併發程式設計實戰】—–執行緒基本概念

轉自 http://cmsblogs.com/?p=1638 共享和可變 要編寫執行緒安全的程式碼，其核心在於對共享的和可變的狀態進行訪問。 “共享”就意味著變數可以被多個執行緒同時訪問。我們知道系統中的資源是有限的，不同的執行緒對資源都是具有著同等的使用權。有限、公平就意味著競爭

java併發程式設計一一多執行緒之間通訊(一)

1.多執行緒之間如何實現通訊 多執行緒之間通訊，其實就是多個執行緒在操作同一個資源，但是操作的動作不同。 1.1什麼是多執行緒之間通訊？ 需求：第一個執行緒寫入（input）使用者，另一個執行緒讀取（out）使用者。實現讀一個，寫一個操作。 1.2多執行緒之間通訊需求？

java併發程式設計一一多執行緒執行緒安全(四)

##1.java重排序 ###1.1資料依賴性 如果兩個操作訪問同一個變數時，且這兩個操作匯中有一個為寫操作，此時這兩個操作之間就 存在資料依賴性。資料依賴分下列三種類型。 名稱 程式碼示例 說明

java併發程式設計一一多執行緒執行緒安全(三)

1.多執行緒的三大特性 1.1什麼是原子性 即一個操作或多個操作要麼全部執行並且執行的過程不會被任何因素打斷，要麼就都不執行。 一個很經典的例子就是銀行賬戶轉賬問題： 比如從賬戶A向賬戶B轉1000元，那麼必然包括2個操作：從賬戶A減去1000元，往賬戶B加上1000元。這2

java併發程式設計一一多執行緒執行緒安全(二)

1.多執行緒死鎖 1.1什麼是多執行緒死鎖？ 同步中巢狀同步，導致鎖無法釋放 程式碼示例： class Thread009 implements Runnable { private int trainCount = 100; private Object

java併發程式設計一一多執行緒執行緒安全(一)

1.什麼是執行緒安全？ 1.1為什麼有執行緒安全問題？ 當多個執行緒同時共享同一個全域性變臉或靜態變數，做寫的操作時，可能會發生資料衝突的問題， 也就是執行緒安全的問題。但是做讀操作是不會發生資料衝突問題。 舉例：現在有100張火車票，有兩個視窗同時搶火車票，用多執行緒模擬搶

java併發程式設計一一多執行緒基礎快速入門

1.執行緒與程序的區別 每個正在系統上執行的程式都是一個程序。每個程序包含一到多個執行緒。執行緒是一組指令的集合，或者是程式的特殊段，他可以在程式裡獨立執行。也可以把它理解為程式碼執行的上下文。 所以執行緒基本是輕量級的程序，它負責在單個程式裡執行任務。通常有作業系統負責多個執行緒

Java併發程式設計(3)-構造執行緒安全類的模式

文章目錄 一、例項限制模式 1.1、 限制變數確保執行緒安全 1.2、分析ArrayList的執行緒安全性 1.3、總結 二、委託執行緒安全模式 2.

【架構】Java併發程式設計 - 深入剖析執行緒池

前言 如果我們要使用執行緒的時候就去建立一個，這樣雖然非常簡便，但是就會有一個問題： 如果併發的執行緒數量很多，並且每個執行緒都是執行一個時間很短的任務就結束了，這樣頻繁建立執行緒就會大大降低系統的效率，因為頻繁建立執行緒和銷燬執行緒需要時間。 那麼有沒有一種辦法使得執行緒可以複用

Java 併發程式設計深入學習——執行緒池及其實現原理

Java執行緒池介紹   執行緒池，從字面含義來看，是指管理一組同構工作執行緒的資源池。執行緒池是與工作佇列（work Queue）密切相關的，其中工作佇列中儲存了所有等待執行的任務。工作者執行緒（Work Thread）的任務很簡單：從工作佇列中獲取一個任務，執行任務，然

Java併發程式設計 之 HashMap執行緒不安全

我想在平時的多執行緒程式設計中，容器的使用是很普遍的，但是你有沒有考慮過有些容器是不安全的，如Haspmap、ArrayList。這裡講解一下Hashmap不安去體現在哪裡。 插入時不安全： 如果有兩個執行緒A和B，都進行插入資料，剛好經過雜湊計算後得到的雜湊碼是一樣的，即插入的

Java併發程式設計之深入執行緒池原理及實現

Java執行緒池在實際的應用開發中十分廣泛。雖然Java1.5之後在JUC包中提供了內建執行緒池可以拿來就用，但是這之前仍有許多老的應用和系統是需要程式設計師自己開發的。因此，基於執行緒池的需求背景、技術要求瞭解執行緒池原理和實現，一方面可以更為深刻理解Java多執行緒開發，有助於解決業務系統中因為執行緒問題

【4】Java併發程式設計：多執行緒中的快取一致性和CAS

一、匯流排鎖定和快取一致性 基本概念 這是兩個作業系統層面的概念。隨著多核時代的到來，併發操作已經成了很正常的現象，作業系統必須要有一些機制和原語，以保證某些基本操作的原子性，比如處理器需要保證讀一個位元組或寫一個位元組是原子的，那麼它是如何實現的呢?有

java併發程式設計實戰：執行緒安全性筆記

執行緒安全性 可以在多個執行緒中呼叫，並且線上程之間不會出現錯誤的互動。 原子性 原子性：即一個操作或者多個操作 要麼全部執行並且執行的過程不會被任何因素打斷，要麼就都不執行。 i++ 和 ++i就不是原子性。 ++i 讀取值，將值加1，將值寫入i.”讀取，修改，寫入

Java併發程式設計系列(一)-執行緒的基本使用

最近在學習java併發程式設計基礎.一切從簡,以能理解概念為主. 併發程式設計肯定繞不過執行緒.這是最基礎的. 那麼就從在java中,如何使用執行緒開始. 繼承Thread類 繼承Thread類,重寫run方法,new出物件,呼叫start方法. 在新啟的執行緒裡執行的就是重寫的run方法. 1 /**

java併發程式設計（對於執行緒內共享變數安全的思考）

        上一篇部落格講解了，多個執行緒之間的互斥和同步的操作，一個是利用了鎖的技術；另一個內則是利用了Object的notify和wait來實現同步操作。這篇部落格呢，來談一下對於執行緒內變

Java併發程式設計筆記4-執行緒池

我們使用執行緒的時候就去建立一個執行緒，但是就會有一個問題：　　如果併發的執行緒數量非常多，而且每個執行緒都是執行一個時間很短的任務就結束了，這樣頻繁建立執行緒就會導致大大降低系統的效率，因為頻繁建立執行緒和銷燬執行緒需要時間。那麼有沒有一種辦法使得執行緒可以複用，就是執行完

java併發程式設計多個執行緒為什麼執行的先後順序不一樣！

jvm為了使得處理器內部的運算單元能儘量被充分利用， 處理器可能會對輸入程式碼進行亂序執行（Out-Of-Order Execution）優化，處理器會在計算之後將亂序執行的結果重組，保證該結果與順序執行的結果是一致的，但並不保證程式中各個語句計算的先後順序與輸入程式碼中的

Java併發程式設計實戰：執行緒池的應用

一、任務與執行策略間的隱形耦合 1、執行緒飢餓死鎖 當任務都是同類、獨立的時候，執行緒池才會有最好的工作表現。如果將耗時的短期的任務混合在一起，除非執行緒池很大，否則會有“塞車”的風險；如果提交的任務要依賴其他的任務，除非池是無限的，否則有產生死鎖的風險。如下程式碼所示，對