JUC組件擴展之FutureTask

1.概述

FutureTask這個組件是JUC裏邊的但是它不是AQS的子類;創建線程有兩種方式，一種是繼承Thread,一種是實現Runnable接口,這兩種方式有一個共同的缺陷就是執行完任務以後無法獲取執行結果,從JDK1.5開始就提供了Future和Callable通過他們可以在任務執行完畢以後獲取結果;

2.Callable Future FutureTask使用方法

① Callable與Runnable接口的對比

Runnable的代碼非常簡單,它是一個接口而且只有一個方法run();創建一個類實現它並在裏邊寫一些操作,然後使用線程去執行該Runnable實現類即可以實現多線程;

②Callable的代碼也非常簡單,不同的是它是一個泛型的接口它裏邊有一個call()方法,call()方法的返回值類型就是我們創建Callable時傳進去的V類型,Callable與Runnable的功能大致相似;相比較而言Callable比Runnable稍微強大一些,因爲Callable對線程執行後可以有返回值並且可以拋出異常;

③Future也是一個接口,Future可以取消任務，查詢任務是否被取消以及獲取結果等操作;通常線程都是異步計算模型的,我們不能直接從別的線程中得到方法的返回值。這個時候我們就可以使用Future來完成;Future可以監視目標線程調用call()的情況,當我們調用Future的get()方法的時候就可以獲取到結果,這個時候通常線程可能不會直接完成,當前線程就會開始阻塞,直到call()方法結束，返回結果線程纔會繼續執行,Future可以得到別的線程任務的方法的返回值。

④ FutureTask它的父類是RunnableFuture,而RunnableFuture繼承了Runnable與Future這兩個接口,由此我們可以直到FutureTask最終也是執行Callable類型的任務,如果構造函數參數是Runnable的話,它會轉換成Callable類型,所以FutureTask即可以作爲Runnable被線程執行也可以作爲Future拿到線程的執行結果;

3.代碼演示

// Future演示
@Slf4j
public class FutureExample {

    static class MyCallable implements Callable<String> {

        @Override
        public String call() throws Exception {
            log.info("do something in callable");
            Thread.sleep(5000);
            return "Done";
        }
    }

    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<String> future = executorService.submit(new MyCallable());
        log.info("do something in main");
        Thread.sleep(1000);
        String result = future.get();
        log.info("result：{}", result);
    }
}

// FutureTask代碼演示
@Slf4j
public class FutureTaskExample {

    public static void main(String[] args) throws Exception {
        FutureTask<String> futureTask = new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                log.info("do something in callable");
                Thread.sleep(5000);
                return "Done";
            }
        });

        new Thread(futureTask).start();
        log.info("do something in main");
        Thread.sleep(1000);
        String result = futureTask.get();
        log.info("result：{}", result);
    }
}

 

3.Fork/Join

ForkJoin框架是JDK7提供的一個，用於並行執行任務的框架,他將一個大任務分割成若干個小任務,最終彙總每個小任務的結果後，得到大任務的結果;從字面上看Fork就是切割任務,Join就是合併結果並得到最終的結果;它主要採取的是工作竊取算法,工作竊取算法主要是指某個線程從其他隊列裏竊取任務來執行;

工作竊取流程圖

 

爲什麼要使用工作竊取算法

原理 :

假如我們需要做一個比較大的任務,我們可以把這個任務分割成互不依賴的子任務,爲了減少線程間的競爭,於是把這些子任務分別放到不同的隊列裏,爲每一個隊列創建一個單獨的線程，來執行隊列裏的任務,線程和隊列一一對應,比如A線程負責處理A線程裏的任務,但是有一些線程會先於其他線程完成任務,這個時候其他線程對應的隊列裏還有任務等待處理,此時就需要使用工作竊取，來讓空閒的線程獲取別的線程的任務;但是這個時候多個線程會訪問同一個隊列,爲了減少竊取任務線程與被竊取任務線程之間競爭通常我們會使用雙端隊列,被竊取任務的線程永遠從雙端隊列的頭部拿任務進行處理,而竊取任務的線程從雙端隊列的底部獲取任務執行;

優點 :

這個工作竊取算法的優點就是充分利用線程進行並行計算並減少了線程間的競爭;

缺點 :

它的缺點是在個別情況下還是會存在競爭(比如雙端隊列裏只有一個任務時),同時這樣也消耗了更多的系統資源(創建了多個線程和多個雙端隊列)

工作竊取算法在ForkJoin中的應用 :

對於ForkJoin框架而言,當一個任務正在等待它使用Join操作創建的子任務結束時,執行這個任務的工作線程查找其他未被執行的任務並開始執行,通過這種方式線程充分利用他們的運行時間來提高應用系統的性能,

ForkJoin的侷限性 :

由於ForkJoin框架使用了工作竊取算法所以執行的任務有一些侷限性;

① 首先任務只能使用Fork和Join操作來實現同步機制,如果使用了其他同步機制,他們在工作時工作線程就不能執行其他任務了;比如在ForkJoin框架中使任務進入休眠狀態,那麼在休眠期間正在執行的工作線程就不會執行其他任務了;

② 我們拆分的任務不應該去執行IO操作(如讀或者寫數據文件);

③ 任務不能拋出檢查異常,必須通過必要的代碼來處理他們;

ForkJoin框架的核心 :

ForkJoinPool : 負責做實現(包括實現工作竊取算法),它管理工作線程和提供關於任務的狀態以及執行信息;

ForkJoinTask : 則主要提供在任務中執行Fork和Join操作的機制;

代碼演示：

// ForkJoinTask代碼演示
@Slf4j
public class ForkJoinTaskExample extends RecursiveTask<Integer> {

    public static final int threshold = 2;
    private int start;
    private int end;

    public ForkJoinTaskExample(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        int sum = 0;

        //如果任務足夠小就計算任務
        boolean canCompute = (end - start) <= threshold;
        if (canCompute) {
            for (int i = start; i <= end; i++) {
                sum += i;
            }
        } else {
            // 如果任務大於閾值，就分裂成兩個子任務計算
            int middle = (start + end) / 2;
            ForkJoinTaskExample leftTask = new ForkJoinTaskExample(start, middle);
            ForkJoinTaskExample rightTask = new ForkJoinTaskExample(middle + 1, end);

            // 執行子任務
            leftTask.fork();
            rightTask.fork();

            // 等待任務執行結束合併其結果
            int leftResult = leftTask.join();
            int rightResult = rightTask.join();

            // 合併子任務
            sum = leftResult + rightResult;
        }
        return sum;
    }

    public static void main(String[] args) {
        ForkJoinPool forkjoinPool = new ForkJoinPool();

        //生成一個計算任務，計算1+2+3+4
        ForkJoinTaskExample task = new ForkJoinTaskExample(1, 100);

        //執行一個任務
        Future<Integer> result = forkjoinPool.submit(task);

        try {
            log.info("result:{}", result.get());
        } catch (Exception e) {
            log.error("exception", e);
        }
    }
}

 

5、BlockQueue

概述

BlockingQueue意思是阻塞隊列,從阻塞這個詞我們就可以看出來在某些情況下對阻塞隊列的訪問可能會造成阻塞;

 

被阻塞的情況

① 當隊列已經滿了的情況下的入隊列操作(除非有另一個線程進行了出隊列操作);

② 當隊列已經空了的情況下的出隊列操作(除非有另一個線程進行了如隊列操作);

適用場景

通過上邊的介紹以及阻塞隊列的特性我們可以得出阻塞隊列是線程安全的,它主要使用在生產者消費者的場景;

阻塞隊列的常用方法

 

它提供了4套方法,大家可以根據自己的實際場景來選擇;

阻塞隊列的實現類

① ArrayBlockingQueue : ArrayBlockingQueue是一個有界的阻塞隊列,它的內部實現是一個數組,它的容量是有限的,我們必須在初始化的時候指定容量的大小且指定的大小值在指定以後就不能在更改,它是以先進先出的方式存儲數據的,最新插入的對象是尾部最新移除的對象是頭部;

② DelayQueue : DelayQueue阻塞的是內部元素,DelayQueue中的元素必須實現Delayed接口,Delayed接口繼承了Comparable接口(因爲DelayQueue中的元素需要進行排序),一般情況下都是按照元素的過期時間優先級進行排序,DelayQueue的應用場景比如定義關閉連接,緩存對象,超時處理等多種場景,它的內部實現用的是lock(鎖)與PriorityQueue(排序)

③ LinkedBlockingQueue : 它的大小是可選的,如果初始化時指定了大小那麼它就是有邊界的如果不指定就是無邊界的(其實使用的默認的最大的整型值),它內部實現是一個鏈表,處理底層的結構不一樣其他的都與ArrayBlockingQueue一樣;它也是以先進先出的方式存儲數據,最新插入的對象在尾部最新移除的對象在頭部,

④ PriorityBlockingQueue : 它是一個帶有優先級的阻塞隊列且它是一個沒有邊界的隊列但是它是有排序規則的,PriorityBlockingQueue是允許插入null的,在使用的PriorityBlockingQueue的時候需要注意,所以插入的對象必須實現Compilable接口,隊列優先級的排序規則就是按照我們對這個接口的實現來定義的,我們可以從PriorityBlockingQueue獲取一個迭代器,但是這個迭代器並不保證按照我們的迭代器進行迭代;

⑤ SynchronousQueue : 這個隊列內部僅允許容納一個元素,當一個線程插入一個元素後就會被阻塞,除非這個元素被另一個線程消費,因此我們又稱之爲同步隊列,它是一個無界非緩存的隊列準確的說它不存儲元素,放入的元素之後等待取走以後才能繼續放入;

⑥ BlockingQueue總結

它不僅實現了一個完整隊列所具有的基本功能同時在多線程環境下還自動了管理多線程間的自動等待 喚醒功能,從而使開發人員可以忽略這些細節關注更高級的功能;