意法半導體推出新款車規碳化矽（SiC）二極體，以滿足電動汽車和插電式混合動力車（PHEVs，Plug-in Hybrids）等新能源汽車對車載充電器（OBCs，on-board battery chargers）在有限空間內處理大功率的苛刻要求。  

  新款二極體採用先進的技術可防止高電流突波燒毀裝置，其過電流保護是額定電流的2.5倍，因此設計人員可選用更小、更經濟實惠且可靠性和效能都不會受到影響的電流更小的二極體。此新碳化矽二極體通過車規產品測試，反向擊穿電壓提高到650V，能滿足設計人員和汽車廠商欲降低電壓補償係數的要求，以確保車載充電半導體元件的標準與瞬間峰值電壓之間有充足的安全邊際。   這次推出的650V二極體包括TO-220AC功率封裝的10A STPSC10H065DY和TO-220AC封裝的12A STPSC12H065DY。此外，TO-220AB封裝的STPSC20H065CTY和TO-247封裝的STPSC20H065CWY是內建２個10A二極體的雙二極體（dual-diode ）產品，可最大幅度地提升空間利用度並減少車載充電器的重量。

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

鴻海於 12 月 22 日公告，以台幣約 24.84 億元入股中國和諧汽車（China Harmony Auto Holding Limited），取得 10.526% 的持股，未來雙方將展開新能源、電動車的通路合作。   和諧汽車為中國進口高級品牌汽車的第二大經銷商，擁有 25 個銷售據點，旗下代理品牌超過 10 個，包括寶馬、勞斯萊斯，MINI、奧迪、法拉利、瑪莎拉蒂等等。   而鴻海集團近來在電動車市場投資與布局也動作頻頻，鴻海集團總裁郭台銘 12 月初率領近 20 人的專家團隊，前往河南首三門峽市的速達電動汽車公司進行實地考察，並駕駛了速達電動車，正式開啟了合作契機。緊接著，富士康與北汽合資電動車租賃公司也傳出獲得中國科技局採用的好消息，成功打入當地電動車租賃市場。   這次，由鴻海主動發布重大訊息，代子公司 Foxconn (Far East) Limited 公告為了與目標公司合作發展新事業，將投資和諧汽車，以港幣約 6.09 億元（約台幣 24.84 億元），每股港幣 4.73 元，取得和諧汽車股份，持股比例將達到 10.526%。   (照片來源：)

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

JDK1.8源碼分析項目（中文註釋）Github地址：

https://github.com/yuanmabiji/jdk1.8-sourcecode-blogs

1 Future是什麼？

先舉個例子，我們平時網購買東西，下單後會生成一個訂單號，然後商家會根據這個訂單號發貨，發貨后又有一個快遞單號，然後快遞公司就會根據這個快遞單號將網購東西快遞給我們。在這一過程中，這一系列的單號都是我們收貨的重要憑證。

因此，JDK的Future就類似於我們網購買東西的單號，當我們執行某一耗時的任務時，我們可以另起一個線程異步去執行這個耗時的任務，同時我們可以干點其他事情。當事情幹完后我們再根據future這個”單號”去提取耗時任務的執行結果即可。因此Future也是多線程中的一種應用模式。

擴展: 說起多線程，那麼Future又與Thread有什麼區別呢？最重要的區別就是Thread是沒有返回結果的，而Future模式是有返回結果的。

2 如何使用Future

前面搞明白了什麼是Future，下面我們再來舉個簡單的例子看看如何使用Future。

假如現在我們要打火鍋，首先我們要準備兩樣東西：把水燒開和準備食材。因為燒開水是一個比較漫長的過程（相當於耗時的業務邏輯），因此我們可以一邊燒開水（相當於另起一個線程），一邊準備火鍋食材（主線程），等兩者都準備好了我們就可以開始打火鍋了。

// DaHuoGuo.java

public class DaHuoGuo {
	public static void main(String[] args) throws Exception {
		FutureTask<String> futureTask = new FutureTask<>(new Callable<String>() {
			@Override
			public String call() throws Exception {
				System.out.println(Thread.currentThread().getName() + ":" + "開始燒開水...");
				// 模擬燒開水耗時
				Thread.sleep(2000);
				System.out.println(Thread.currentThread().getName() + ":"  + "開水已經燒好了...");
				return "開水";
			}
		});

		Thread thread = new Thread(futureTask);
		thread.start();

		// do other thing
		System.out.println(Thread.currentThread().getName() + ":"  + " 此時開啟了一個線程執行future的邏輯（燒開水），此時我們可以干點別的事情（比如準備火鍋食材）...");
		// 模擬準備火鍋食材耗時
		Thread.sleep(3000);
		System.out.println(Thread.currentThread().getName() + ":"  + "火鍋食材準備好了");
		String shicai = "火鍋食材";

		// 開水已經稍好，我們取得燒好的開水
		String boilWater = futureTask.get();

		System.out.println(Thread.currentThread().getName() + ":"  + boilWater + "和" + shicai + "已經準備好，我們可以開始打火鍋啦");
	}
}

執行結果如下截圖，符合我們的預期：

從以上代碼中可以看到，我們使用Future主要有以下步驟：

1. 新建一個Callable匿名函數實現類對象，我們的業務邏輯在Callable的call方法中實現，其中Callable的泛型是返回結果類型；
2. 然後把Callable匿名函數對象作為FutureTask的構造參數傳入，構建一個futureTask對象；
3. 然後再把futureTask對象作為Thread構造參數傳入並開啟這個線程執行去執行業務邏輯；
4. 最後我們調用futureTask對象的get方法得到業務邏輯執行結果。

可以看到跟Future使用有關的JDK類主要有FutureTask和Callable兩個，下面主要對FutureTask進行源碼分析。

擴展： 還有一種使用Future的方式是將Callable實現類提交給線程池執行的方式，這裏不再介紹，自行百度即可。

3 FutureTask類結構分析

我們先來看下FutureTask的類結構：

可以看到FutureTask實現了RunnableFuture接口，而RunnableFuture接口又繼承了Future和Runnable接口。因為FutureTask間接實現了Runnable接口，因此可以作為任務被線程Thread執行；此外，最重要的一點就是FutureTask還間接實現了Future接口，因此還可以獲得任務執行的結果。下面我們就來簡單看看這幾個接口的相關api。

// Runnable.java

@FunctionalInterface
public interface Runnable {
    // 執行線程任務
    public abstract void run();
}

Runnable沒啥好說的，相信大家都已經很熟悉了。

// Future.java

public interface Future<V> {
    /**
     * 嘗試取消線程任務的執行，分為以下幾種情況：
     * 1）如果線程任務已經完成或已經被取消或其他原因不能被取消，此時會失敗並返回false；
     * 2）如果任務還未開始執行，此時執行cancel方法，那麼任務將被取消執行，此時返回true；TODO 此時對應任務狀態state的哪種狀態？？？不懂！！
     * 3）如果任務已經開始執行，那麼mayInterruptIfRunning這個參數將決定是否取消任務的執行。
     *    這裏值得注意的是，cancel(true)實質並不能真正取消線程任務的執行，而是發出一個線程
     *    中斷的信號，一般需要結合Thread.currentThread().isInterrupted()來使用。
     */
    boolean cancel(boolean mayInterruptIfRunning);
    /**
     * 判斷任務是否被取消，在執行任務完成前被取消，此時會返回true
     */
    boolean isCancelled();
    /**
     * 這個方法不管任務正常停止，異常還是任務被取消，總是返回true。
     */
    boolean isDone();
    /**
     * 獲取任務執行結果，注意是阻塞等待獲取任務執行結果。
     */
    V get() throws InterruptedException, ExecutionException;
    /**
     * 獲取任務執行結果，注意是阻塞等待獲取任務執行結果。
     * 只不過在規定的時間內未獲取到結果，此時會拋出超時異常
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Future接口象徵著異步執行任務的結果即執行一個耗時任務完全可以另起一個線程執行，然後此時我們可以去做其他事情，做完其他事情我們再調用Future.get()方法獲取結果即可，此時若異步任務還沒結束，此時會一直阻塞等待，直到異步任務執行完獲取到結果。

// RunnableFuture.java

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

RunnableFuture是Future和Runnable接口的組合，即這個接口表示又可以被線程異步執行，因為實現了Runnable接口，又可以獲得線程異步任務的執行結果，因為實現了Future接口。因此解決了Runnable異步任務沒有返回結果的缺陷。

接下來我們來看下FutureTask，FutureTask實現了RunnableFuture接口，因此是Future和Runnable接口的具體實現類，是一個可被取消的異步線程任務，提供了Future的基本實現，即異步任務執行后我們能夠獲取到異步任務的執行結果，是我們接下來分析的重中之重。FutureTask可以包裝一個Callable和Runnable對象，此外,FutureTask除了可以被線程執行外，還可以被提交給線程池執行。

我們先看下FutureTask類的api，其中重點方法已經紅框框出。

上圖中FutureTask的run方法是被線程異步執行的方法，get方法即是取得異步任務執行結果的方法，還有cancel方法是取消任務執行的方法。接下來我們主要對這三個方法進行重點分析。

思考：

1. FutureTask覆寫的run方法的返回類型依然是void，表示沒有返回值，那麼FutureTask的get方法又是如何獲得返回值的呢？
2. FutureTask的cancel方法能真正取消線程異步任務的執行么？什麼情況下能取消？

因為FutureTask異步任務執行結果還跟Callable接口有關，因此我們再來看下Callable接口：

// Callable.java

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     */
    V call() throws Exception;
}

我們都知道，Callable<V>接口和Runnable接口都可以被提交給線程池執行，唯一不同的就是Callable<V>接口是有返回結果的，其中的泛型V就是返回結果，而Runnable接口是沒有返回結果的。

思考： 一般情況下，Runnable接口實現類才能被提交給線程池執行，為何Callable接口實現類也可以被提交給線程池執行？想想線程池的submit方法內部有對Callable做適配么？

4 FutureTask源碼分析

4.1 FutureTask成員變量

我們首先來看下FutureTask的成員變量有哪些,理解這些成員變量對後面的源碼分析非常重要。

// FutureTask.java

/** 封裝的Callable對象，其call方法用來執行異步任務 */
private Callable<V> callable;
/** 在FutureTask裏面定義一個成員變量outcome，用來裝異步任務的執行結果 */
private Object outcome; // non-volatile, protected by state reads/writes
/** 用來執行callable任務的線程 */
private volatile Thread runner;
/** 線程等待節點，reiber stack的一種實現 */
private volatile WaitNode waiters;
/** 任務執行狀態 */
private volatile int state;

// Unsafe mechanics
private static final sun.misc.Unsafe UNSAFE;
// 對應成員變量state的偏移地址
private static final long stateOffset;
// 對應成員變量runner的偏移地址
private static final long runnerOffset;
// 對應成員變量waiters的偏移地址
private static final long waitersOffset;

這裏我們要重點關注下FutureTask的Callable成員變量，因為FutureTask的異步任務最終是委託給Callable去實現的。

思考：

1. FutureTask的成員變量runner,waiters和state都被volatile修飾，我們可以思考下為什麼這三個成員變量需要被volatile修飾，而其他成員變量又不用呢？volatile關鍵字的作用又是什麼呢？
2. 既然已經定義了成員變量runner,waiters和state了，此時又定義了stateOffset,runnerOffset和waitersOffset變量分別對應runner,waiters和state的偏移地址，為何要多此一舉呢？

我們再來看看stateOffset,runnerOffset和waitersOffset變量這三個變量的初始化過程：

// FutureTask.java

static {
    try {
        UNSAFE = sun.misc.Unsafe.getUnsafe();
        Class<?> k = FutureTask.class;
        stateOffset = UNSAFE.objectFieldOffset
            (k.getDeclaredField("state"));
        runnerOffset = UNSAFE.objectFieldOffset
            (k.getDeclaredField("runner"));
        waitersOffset = UNSAFE.objectFieldOffset
            (k.getDeclaredField("waiters"));
    } catch (Exception e) {
        throw new Error(e);
    }
    }

4.2 FutureTask的狀態變化

前面講了FutureTask的成員變量，有一個表示狀態的成員變量state我們要重點關注下，state變量表示任務執行的狀態。

// FutureTask.java

/** 任務執行狀態 */
private volatile int state;
/** 任務新建狀態 */
private static final int NEW          = 0;
/** 任務正在完成狀態，是一個瞬間過渡狀態 */
private static final int COMPLETING   = 1;
/** 任務正常結束狀態 */
private static final int NORMAL       = 2;
/** 任務執行異常狀態 */
private static final int EXCEPTIONAL  = 3;
/** 任務被取消狀態，對應cancel(false) */
private static final int CANCELLED    = 4;
/** 任務中斷狀態，是一個瞬間過渡狀態 */
private static final int INTERRUPTING = 5;
/** 任務被中斷狀態，對應cancel(true) */
private static final int INTERRUPTED  = 6;

可以看到任務狀態變量state有以上7種狀態，0-6分別對應着每一種狀態。任務狀態一開始是NEW,然後由FutureTask的三個方法set,setException和cancel來設置狀態的變化，其中狀態變化有以下四種情況：

1. NEW -> COMPLETING -> NORMAL:這個狀態變化表示異步任務的正常結束，其中COMPLETING是一個瞬間臨時的過渡狀態，由set方法設置狀態的變化；
2. NEW -> COMPLETING -> EXCEPTIONAL:這個狀態變化表示異步任務執行過程中拋出異常，由setException方法設置狀態的變化；
3. NEW -> CANCELLED:這個狀態變化表示被取消，即調用了cancel(false)，由cancel方法來設置狀態變化；
4. NEW -> INTERRUPTING -> INTERRUPTED:這個狀態變化表示被中斷，即調用了cancel(true)，由cancel方法來設置狀態變化。

4.3 FutureTask構造函數

FutureTask有兩個構造函數，我們分別來看看：

// FutureTask.java

// 第一個構造函數
public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}

可以看到，這個構造函數在我們前面舉的“打火鍋”的例子代碼中有用到，就是Callable成員變量賦值，在異步執行任務時再調用Callable.call方法執行異步任務邏輯。此外，此時給任務狀態state賦值為NEW，表示任務新建狀態。

我們再來看下FutureTask的另外一個構造函數：

// FutureTask.java

// 另一個構造函數
public FutureTask(Runnable runnable, V result) {
    this.callable = Executors.callable(runnable, result);
    this.state = NEW;       // ensure visibility of callable
}

這個構造函數在執行Executors.callable(runnable, result)時是通過適配器RunnableAdapter來將Runnable對象runnable轉換成Callable對象，然後再分別給callable和state變量賦值。

注意，這裏我們需要記住的是FutureTask新建時，此時的任務狀態state是NEW就好了。

4.4 FutureTask.run方法,用來執行異步任務

前面我們有講到FutureTask間接實現了Runnable接口，覆寫了Runnable接口的run方法，因此該覆寫的run方法是提交給線程來執行的，同時，該run方法正是執行異步任務邏輯的方法，那麼，執行完run方法又是如何保存異步任務執行的結果的呢？

我們現在着重來分析下run方法：

// FutureTask.java

public void run() {
    // 【1】,為了防止多線程併發執行異步任務，這裏需要判斷線程滿不滿足執行異步任務的條件，有以下三種情況：
    // 1）若任務狀態state為NEW且runner為null，說明還未有線程執行過異步任務，此時滿足執行異步任務的條件，
    // 此時同時調用CAS方法為成員變量runner設置當前線程的值；
    // 2）若任務狀態state為NEW且runner不為null，任務狀態雖為NEW但runner不為null，說明有線程正在執行異步任務，
    // 此時不滿足執行異步任務的條件，直接返回；
    // 1）若任務狀態state不為NEW，此時不管runner是否為null，說明已經有線程執行過異步任務，此時沒必要再重新
    // 執行一次異步任務，此時不滿足執行異步任務的條件；
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return;
    try {
        // 拿到之前構造函數傳進來的callable實現類對象，其call方法封裝了異步任務執行的邏輯
        Callable<V> c = callable;
        // 若任務還是新建狀態的話，那麼就調用異步任務
        if (c != null && state == NEW) {
            // 異步任務執行結果
            V result;
            // 異步任務執行成功還是始遍標誌
            boolean ran;
            try {
                // 【2】，執行異步任務邏輯，並把執行結果賦值給result
                result = c.call();
                // 若異步任務執行過程中沒有拋出異常，說明異步任務執行成功，此時設置ran標誌為true
                ran = true;
            } catch (Throwable ex) {
                result = null;
                // 異步任務執行過程拋出異常，此時設置ran標誌為false
                ran = false;
                // 【3】設置異常，裏面也設置state狀態的變化
                setException(ex);
            }
            // 【3】若異步任務執行成功，此時設置異步任務執行結果，同時也設置狀態的變化
            if (ran)
                set(result);
        }
    } finally {
        // runner must be non-null until state is settled to
        // prevent concurrent calls to run()
        // 異步任務正在執行過程中，runner一直是非空的，防止併發調用run方法，前面有調用cas方法做判斷的
        // 在異步任務執行完后，不管是正常結束還是異常結束，此時設置runner為null
        runner = null;
        // state must be re-read after nulling runner to prevent
        // leaked interrupts
        // 線程執行異步任務后的任務狀態
        int s = state;
        // 【4】如果執行了cancel(true)方法，此時滿足條件，
        // 此時調用handlePossibleCancellationInterrupt方法處理中斷
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

可以看到執行異步任務的run方法主要分為以下四步來執行：

1. 判斷線程是否滿足執行異步任務的條件：為了防止多線程併發執行異步任務，這裏需要判斷線程滿不滿足執行異步任務的條件；
2. 若滿足條件，執行異步任務：因為異步任務邏輯封裝在Callable.call方法中，此時直接調用Callable.call方法執行異步任務，然後返回執行結果；
3. 根據異步任務的執行情況做不同的處理：1） 若異步任務執行正常結束，此時調用set(result);來設置任務執行結果；2）若異步任務執行拋出異常，此時調用setException(ex);來設置異常,詳細分析請見4.4.1小節；
4. 異步任務執行完后的善後處理工作：不管異步任務執行成功還是失敗，若其他線程有調用FutureTask.cancel(true)，此時需要調用handlePossibleCancellationInterrupt方法處理中斷，詳細分析請見4.4.2小節。

這裏值得注意的是判斷線程滿不滿足執行異步任務條件時,runner是否為null是調用UNSAFE的CAS方法compareAndSwapObject來判斷和設置的，同時compareAndSwapObject是通過成員變量runner的偏移地址runnerOffset來給runner賦值的，此外，成員變量runner被修飾為volatile是在多線程的情況下， 一個線程的volatile修飾變量的設值能夠立即刷進主存，因此值便可被其他線程可見。

4.4.1 FutureTask的set和setException方法

下面我們來看下當異步任務執行正常結束時，此時會調用set(result);方法：

// FutureTask.java

protected void set(V v) {
    // 【1】調用UNSAFE的CAS方法判斷任務當前狀態是否為NEW，若為NEW，則設置任務狀態為COMPLETING
    // 【思考】此時任務不能被多線程併發執行，什麼情況下會導致任務狀態不為NEW？
    // 答案是只有在調用了cancel方法的時候，此時任務狀態不為NEW，此時什麼都不需要做，
    // 因此需要調用CAS方法來做判斷任務狀態是否為NEW
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        // 【2】將任務執行結果賦值給成員變量outcome
        outcome = v;
        // 【3】將任務狀態設置為NORMAL，表示任務正常結束
        UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
        // 【4】調用任務執行完成方法，此時會喚醒阻塞的線程，調用done()方法和清空等待線程鏈表等
        finishCompletion();
    }
}

可以看到當異步任務正常執行結束后，且異步任務沒有被cancel的情況下，此時會做以下事情：將任務執行結果保存到FutureTask的成員變量outcome中的，賦值結束後會調用finishCompletion方法來喚醒阻塞的線程（哪裡來的阻塞線程？後面會分析），值得注意的是這裏對應的任務狀態變化是NEW -> COMPLETING -> NORMAL。

我們繼續來看下當異步任務執行過程中拋出異常，此時會調用setException(ex);方法。

// FutureTask.java

protected void setException(Throwable t) {
    // 【1】調用UNSAFE的CAS方法判斷任務當前狀態是否為NEW，若為NEW，則設置任務狀態為COMPLETING
    // 【思考】此時任務不能被多線程併發執行，什麼情況下會導致任務狀態不為NEW？
    // 答案是只有在調用了cancel方法的時候，此時任務狀態不為NEW，此時什麼都不需要做，
    // 因此需要調用CAS方法來做判斷任務狀態是否為NEW
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        // 【2】將異常賦值給成員變量outcome
        outcome = t;
        // 【3】將任務狀態設置為EXCEPTIONAL
        UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
        // 【4】調用任務執行完成方法，此時會喚醒阻塞的線程，調用done()方法和清空等待線程鏈表等
        finishCompletion();
    }
}

可以看到setException(Throwable t)的代碼邏輯跟前面的set(V v)幾乎一樣，不同的是任務執行過程中拋出異常，此時是將異常保存到FutureTask的成員變量outcome中，還有，值得注意的是這裏對應的任務狀態變化是NEW -> COMPLETING -> EXCEPTIONAL。

因為異步任務不管正常還是異常結束，此時都會調用FutureTask的finishCompletion方法來喚醒喚醒阻塞的線程，這裏阻塞的線程是指我們調用Future.get方法時若異步任務還未執行完，此時該線程會阻塞。

// FutureTask.java

private void finishCompletion() {
    // assert state > COMPLETING;
    // 取出等待線程鏈表頭節點，判斷頭節點是否為null
    // 1）若線程鏈表頭節點不為空，此時以“後進先出”的順序（棧）移除等待的線程WaitNode節點
    // 2）若線程鏈表頭節點為空，說明還沒有線程調用Future.get()方法來獲取任務執行結果，固然不用移除
    for (WaitNode q; (q = waiters) != null;) {
        // 調用UNSAFE的CAS方法將成員變量waiters設置為空
        if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
            for (;;) {
                // 取出WaitNode節點的線程
                Thread t = q.thread;
                // 若取出的線程不為null，則將該WaitNode節點線程置空，且喚醒正在阻塞的該線程
                if (t != null) {
                    q.thread = null;
                    //【重要】喚醒正在阻塞的該線程
                    LockSupport.unpark(t);
                }
                // 繼續取得下一個WaitNode線程節點
                WaitNode next = q.next;
                // 若沒有下一個WaitNode線程節點，說明已經將所有等待的線程喚醒，此時跳出for循環
                if (next == null)
                    break;
                // 將已經移除的線程WaitNode節點的next指針置空，此時好被垃圾回收
                q.next = null; // unlink to help gc
                // 再把下一個WaitNode線程節點置為當前線程WaitNode頭節點
                q = next;
            }
            break;
        }
    }
    // 不管任務正常執行還是拋出異常，都會調用done方法
    done();
    // 因為異步任務已經執行完且結果已經保存到outcome中，因此此時可以將callable對象置空了
    callable = null;        // to reduce footprint
}

finishCompletion方法的作用就是不管異步任務正常還是異常結束，此時都要喚醒且移除線程等待鏈表的等待線程節點，這個鏈表實現的是一個是Treiber stack，因此喚醒（移除）的順序是”後進先出”即後面先來的線程先被先喚醒（移除），關於這個線程等待鏈表是如何成鏈的，後面再繼續分析。

4.4.2 FutureTask的handlePossibleCancellationInterrupt方法

在4.4小節分析的run方法里的最後有一個finally塊，此時若任務狀態state >= INTERRUPTING，此時說明有其他線程執行了cancel(true)方法，此時需要讓出CPU執行的時間片段給其他線程執行，我們來看下具體的源碼：

// FutureTask.java

private void handlePossibleCancellationInterrupt(int s) {
    // It is possible for our interrupter to stall before getting a
    // chance to interrupt us.  Let's spin-wait patiently.
    // 當任務狀態是INTERRUPTING時，此時讓出CPU執行的機會，讓其他線程執行
    if (s == INTERRUPTING)
        while (state == INTERRUPTING)
            Thread.yield(); // wait out pending interrupt

    // assert state == INTERRUPTED;

    // We want to clear any interrupt we may have received from
    // cancel(true).  However, it is permissible to use interrupts
    // as an independent mechanism for a task to communicate with
    // its caller, and there is no way to clear only the
    // cancellation interrupt.
    //
    // Thread.interrupted();
}

思考： 為啥任務狀態是INTERRUPTING時，此時就要讓出CPU執行的時間片段呢？還有為什麼要在義務任務執行后才調用handlePossibleCancellationInterrupt方法呢？

4.5 FutureTask.get方法,獲取任務執行結果

前面我們起一個線程在其`run`方法中執行異步任務后，此時我們可以調用`FutureTask.get`方法來獲取異步任務執行的結果。

// FutureTask.java

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    // 【1】若任務狀態<=COMPLETING，說明任務正在執行過程中，此時可能正常結束，也可能遇到異常
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    // 【2】最後根據任務狀態來返回任務執行結果，此時有三種情況：1）任務正常執行；2）任務執行異常；3）任務被取消
    return report(s);
}

可以看到，如果任務狀態state<=COMPLETING，說明異步任務正在執行過程中，此時會調用awaitDone方法阻塞等待；當任務執行完后，此時再調用report方法來報告任務結果，此時有三種情況：1）任務正常執行；2）任務執行異常；3）任務被取消。

4.5.1 FutureTask.awaitDone方法

FutureTask.awaitDone方法會阻塞獲取異步任務執行結果的當前線程，直到異步任務執行完成。

// FutureTask.java

private int awaitDone(boolean timed, long nanos)
    throws InterruptedException {
    // 計算超時結束時間
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    // 線程鏈表頭節點
    WaitNode q = null;
    // 是否入隊
    boolean queued = false;
    // 死循環
    for (;;) {
        // 如果當前獲取任務執行結果的線程被中斷，此時移除該線程WaitNode鏈表節點，並拋出InterruptedException
        if (Thread.interrupted()) {
            removeWaiter(q);
            throw new InterruptedException();
        }

        int s = state;
        // 【5】如果任務狀態>COMPLETING，此時返回任務執行結果，其中此時任務可能正常結束（NORMAL）,可能拋出異常（EXCEPTIONAL）
        // 或任務被取消（CANCELLED，INTERRUPTING或INTERRUPTED狀態的一種）
        if (s > COMPLETING) {
            // 【問】此時將當前WaitNode節點的線程置空，其中在任務結束時也會調用finishCompletion將WaitNode節點的thread置空，
            // 這裏為什麼又要再調用一次q.thread = null;呢？
            // 【答】因為若很多線程來獲取任務執行結果，在任務執行完的那一刻，此時獲取任務的線程要麼已經在線程等待鏈表中，要麼
            // 此時還是一個孤立的WaitNode節點。在線程等待鏈表中的的所有WaitNode節點將由finishCompletion來移除（同時喚醒）所有
            // 等待的WaitNode節點，以便垃圾回收；而孤立的線程WaitNode節點此時還未阻塞，因此不需要被喚醒，此時只要把其屬性置為
            // null，然後其有沒有被誰引用，因此可以被GC。
            if (q != null)
                q.thread = null;
            // 【重要】返回任務執行結果
            return s;
        }
        // 【4】若任務狀態為COMPLETING，此時說明任務正在執行過程中，此時獲取任務結果的線程需讓出CPU執行時間片段
        else if (s == COMPLETING) // cannot time out yet
            Thread.yield();
        // 【1】若當前線程還沒有進入線程等待鏈表的WaitNode節點，此時新建一個WaitNode節點，並把當前線程賦值給WaitNode節點的thread屬性
        else if (q == null)
            q = new WaitNode();
        // 【2】若當前線程等待節點還未入線程等待隊列，此時加入到該線程等待隊列的頭部
        else if (!queued)
            queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                 q.next = waiters, q);
        // 若有超時設置，那麼處理超時獲取任務結果的邏輯
        else if (timed) {
            nanos = deadline - System.nanoTime();
            if (nanos <= 0L) {
                removeWaiter(q);
                return state;
            }
            LockSupport.parkNanos(this, nanos);
        }
        // 【3】若沒有超時設置，此時直接阻塞當前線程
        else
            LockSupport.park(this);
    }
}

FutureTask.awaitDone方法主要做的事情總結如下：

1. 首先awaitDone方法裏面是一個死循環；
2. 若獲取結果的當前線程被其他線程中斷，此時移除該線程WaitNode鏈表節點，並拋出InterruptedException；
3. 如果任務狀態state>COMPLETING，此時返回任務執行結果；
4. 若任務狀態為COMPLETING，此時獲取任務結果的線程需讓出CPU執行時間片段；
5. 若q == null，說明當前線程還未設置到WaitNode節點，此時新建WaitNode節點並設置其thread屬性為當前線程；
6. 若queued==false，說明當前線程WaitNode節點還未加入線程等待鏈表，此時加入該鏈表的頭部；
7. 當timed設置為true時，此時該方法具有超時功能，關於超時的邏輯這裏不詳細分析；
8. 當前面6個條件都不滿足時，此時阻塞當前線程。

我們分析到這裏，可以直到執行異步任務只能有一個線程來執行，而獲取異步任務結果可以多線程來獲取，當異步任務還未執行完時，此時獲取異步任務結果的線程會加入線程等待鏈表中，然後調用調用LockSupport.park(this);方法阻塞當前線程。直到異步任務執行完成，此時會調用finishCompletion方法來喚醒並移除線程等待鏈表的每個WaitNode節點，這裏這裏喚醒（移除）WaitNode節點的線程是從鏈表頭部開始的，前面我們也已經分析過。

還有一個特別需要注意的就是awaitDone方法裏面是一個死循環，當一個獲取異步任務的線程進來后可能會多次進入多個條件分支執行不同的業務邏輯，也可能只進入一個條件分支。下面分別舉兩種可能的情況進行說明：

情況1：
當獲取異步任務結果的線程進來時，此時異步任務還未執行完即state=NEW且沒有超時設置時：

1. 第一次循環：此時q = null，此時進入上面代碼標號【1】的判斷分支，即為當前線程新建一個WaitNode節點；
2. 第二次循環：此時queued = false，此時進入上面代碼標號【2】的判斷分支，即將之前新建的WaitNode節點加入線程等待鏈表中；
3. 第三次循環：此時進入上面代碼標號【3】的判斷分支，即阻塞當前線程；
4. 第四次循環：加入此時異步任務已經執行完，此時進入上面代碼標號【5】的判斷分支，即返回異步任務執行結果。

情況2：
當獲取異步任務結果的線程進來時，此時異步任務已經執行完即state>COMPLETING且沒有超時設置時,此時直接進入上面代碼標號【5】的判斷分支，即直接返回異步任務執行結果即可，也不用加入線程等待鏈表了。

4.5.2 FutureTask.report方法

在get方法中，當異步任務執行結束后即不管異步任務正常還是異常結束，亦或是被cancel，此時獲取異步任務結果的線程都會被喚醒，因此會繼續執行FutureTask.report方法報告異步任務的執行情況，此時可能會返回結果，也可能會拋出異常。

// FutureTask.java

private V report(int s) throws ExecutionException {
    // 將異步任務執行結果賦值給x，此時FutureTask的成員變量outcome要麼保存着
    // 異步任務正常執行的結果，要麼保存着異步任務執行過程中拋出的異常
    Object x = outcome;
    // 【1】若異步任務正常執行結束，此時返回異步任務執行結果即可
    if (s == NORMAL)
        return (V)x;
    // 【2】若異步任務執行過程中，其他線程執行過cancel方法，此時拋出CancellationException異常
    if (s >= CANCELLED)
        throw new CancellationException();
    // 【3】若異步任務執行過程中，拋出異常，此時將該異常轉換成ExecutionException后，重新拋出。
    throw new ExecutionException((Throwable)x);
}

4.6 FutureTask.cancel方法,取消執行任務

我們最後再來看下FutureTask.cancel方法，我們一看到FutureTask.cancel方法，肯定一開始就天真的認為這是一個可以取消異步任務執行的方法，如果我們這樣認為的話，只能說我們猜對了一半。

// FutureTask.java

public boolean cancel(boolean mayInterruptIfRunning) {
    // 【1】判斷當前任務狀態，若state == NEW時根據mayInterruptIfRunning參數值給當前任務狀態賦值為INTERRUPTING或CANCELLED
    // a）當任務狀態不為NEW時，說明異步任務已經完成，或拋出異常，或已經被取消，此時直接返回false。
    // TODO 【問題】此時若state = COMPLETING呢？此時為何也直接返回false，而不能發出中斷異步任務線程的中斷信號呢？？
    // TODO 僅僅因為COMPLETING是一個瞬時態嗎？？？
    // b）當前僅當任務狀態為NEW時，此時若mayInterruptIfRunning為true，此時任務狀態賦值為INTERRUPTING；否則賦值為CANCELLED。
    if (!(state == NEW &&
          UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
              mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
        return false;
    try {    // in case call to interrupt throws exception
        // 【2】如果mayInterruptIfRunning為true，此時中斷執行異步任務的線程runner（還記得執行異步任務時就把執行異步任務的線程就賦值給了runner成員變量嗎）
        if (mayInterruptIfRunning) {
            try {
                Thread t = runner;
                if (t != null)
                    // 中斷執行異步任務的線程runner
                    t.interrupt();
            } finally { // final state
                // 最後任務狀態賦值為INTERRUPTED
                UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
            }
        }
    // 【3】不管mayInterruptIfRunning為true還是false，此時都要調用finishCompletion方法喚醒阻塞的獲取異步任務結果的線程並移除線程等待鏈表節點
    } finally {
        finishCompletion();
    }
    // 返回true
    return true;
}

以上代碼中，當異步任務狀態state != NEW時，說明異步任務已經正常執行完或已經異常結束亦或已經被cancel，此時直接返回false;當異步任務狀態state = NEW時，此時又根據mayInterruptIfRunning參數是否為true分為以下兩種情況：

1. 當mayInterruptIfRunning = false時，此時任務狀態state直接被賦值為CANCELLED，此時不會對執行異步任務的線程發出中斷信號，值得注意的是這裏對應的任務狀態變化是NEW -> CANCELLED。
2. 當mayInterruptIfRunning = true時，此時會對執行異步任務的線程發出中斷信號，值得注意的是這裏對應的任務狀態變化是NEW -> INTERRUPTING -> INTERRUPTED。

最後不管mayInterruptIfRunning為true還是false，此時都要調用finishCompletion方法喚醒阻塞的獲取異步任務結果的線程並移除線程等待鏈表節點。

從FutureTask.cancel源碼中我們可以得出答案，該方法並不能真正中斷正在執行異步任務的線程，只能對執行異步任務的線程發出中斷信號。如果執行異步任務的線程處於sleep、wait或join的狀態中，此時會拋出InterruptedException異常，該線程可以被中斷；此外，如果異步任務需要在while循環執行的話，此時可以結合以下代碼來結束異步任務線程，即執行異步任務的線程被中斷時，此時Thread.currentThread().isInterrupted()返回true，不滿足while循環條件因此退出循環，結束異步任務執行線程，如下代碼：

public Integer call() throws Exception {
    while (!Thread.currentThread().isInterrupted()) {
        // 業務邏輯代碼
        System.out.println("running...");

    }
    return 666;
}

注意：調用了FutureTask.cancel方法，只要返回結果是true，假如異步任務線程雖然不能被中斷，即使異步任務線程正常執行完畢，返回了執行結果，此時調用FutureTask.get方法也不能夠獲取異步任務執行結果，此時會拋出CancellationException異常。請問知道這是為什麼嗎？

因為調用了FutureTask.cancel方法，只要返回結果是true，此時的任務狀態為CANCELLED或INTERRUPTED,同時必然會執行finishCompletion方法，而finishCompletion方法會喚醒獲取異步任務結果的線程等待列表的線程，而獲取異步任務結果的線程喚醒后發現狀態s >= CANCELLED，此時就會拋出CancellationException異常了。

5 總結

好了，本篇文章對FutureTask的源碼分析就到此結束了，下面我們再總結下FutureTask的實現邏輯：

1. 我們實現Callable接口，在覆寫的call方法中定義需要執行的業務邏輯；
2. 然後把我們實現的Callable接口實現對象傳給FutureTask，然後FutureTask作為異步任務提交給線程執行；
3. 最重要的是FutureTask內部維護了一個狀態state，任何操作（異步任務正常結束與否還是被取消）都是圍繞着這個狀態進行，並隨時更新state任務的狀態；
4. 只能有一個線程執行異步任務，當異步任務執行結束后，此時可能正常結束，異常結束或被取消。
5. 可以多個線程併發獲取異步任務執行結果，當異步任務還未執行完，此時獲取異步任務的線程將加入線程等待列表進行等待；
6. 當異步任務線程執行結束后，此時會喚醒獲取異步任務執行結果的線程，注意喚醒順序是”後進先出”即後面加入的阻塞線程先被喚醒。
7. 當我們調用FutureTask.cancel方法時並不能真正停止執行異步任務的線程，只是發出中斷線程的信號。但是只要cancel方法返回true，此時即使異步任務能正常執行完，此時我們調用get方法獲取結果時依然會拋出CancellationException異常。

擴展： 前面我們提到了FutureTask的runner,waiters和state都是用volatile關鍵字修飾，說明這三個變量都是多線程共享的對象（成員變量），會被多線程操作，此時用volatile關鍵字修飾是為了一個線程操作volatile屬性變量值后，能夠及時對其他線程可見。此時多線程操作成員變量僅僅用了volatile關鍵字仍然會有線程安全問題的，而此時Doug Lea老爺子沒有引入任何線程鎖，而是採用了Unsafe的CAS方法來代替鎖操作，確保線程安全性。

6 分析FutureTask源碼，我們能學到什麼？

我們分析源碼的目的是什麼？除了弄懂FutureTask的內部實現原理外，我們還要借鑒大佬寫寫框架源碼的各種技巧，只有這樣，我們才能成長。

分析了FutureTask源碼，我們可以從中學到：

1. 利用LockSupport來實現線程的阻塞\喚醒機制；
2. 利用volatile和UNSAFE的CAS方法來實現線程共享變量的無鎖化操作；
3. 若要編寫超時異常的邏輯可以參考FutureTask的get(long timeout, TimeUnit unit)的實現邏輯；
4. 多線程獲取某一成員變量結果時若需要等待時的線程等待鏈表的邏輯實現；
5. 某一異步任務在某一時刻只能由單一線程執行的邏輯實現；
6. FutureTask中的任務狀態satate的變化處理的邏輯實現。
7. …

以上列舉的幾點都是我們可以學習參考的地方。

若您覺得不錯，請無情的轉發和點贊吧！

【源碼筆記】Github地址：

https://github.com/yuanmabiji/Java-SourceCode-Blogs

公眾號【源碼筆記】，專註於Java後端系列框架的源碼分析。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

我是風箏，公眾號「古時的風箏」，一個兼具深度與廣度的程序員鼓勵師，一個本打算寫詩卻寫起了代碼的田園碼農！
文章會收錄在 JavaNewBee 中，更有 Java 後端知識圖譜，從小白到大牛要走的路都在裏面。

程序員上班戴耳機聽歌難道不是正常的嗎，真的還有公司不允許程序員戴耳機的嗎？不戴耳機能寫代碼？

那程序員的耳機里聽的是什麼呢？我採訪了一眾程序員朋友。

鋼鐵程序員王二麻子同學

聽的什麼？我根本就不知道，我只是不想讓別人打擾我

有時候開發確實是比較費腦子的，尤其是遇到複雜邏輯的時候。正當思如泉涌、靈感迸發的時候，旁人看着我坐在那裡一動不動，好像什麼都沒有做，其實我腦子里正在構思一個複雜的流程。

這時候，突然有個人走過來打斷我，前面的思考都白費了，你說傷心不，你說氣人不。

所以，為了防止上面的情況出現，不得不戴上耳機。至於聽什麼，不重要，我只是告訴別人，別過來，我現在沒時間。

生活需要儀式感的劉精神同學

聽什麼不重要，關鍵是儀式感

生活需要儀式感，寫代碼也需要儀式感啊。當我戴上耳機的那一刻，我感覺精神抖擻，彷彿遊離的三魂六魄都回來了，寫代碼更有動力。

要是不戴耳機，感覺渾身無力，只想摸魚，寫代碼什麼的，根本想都想不起來。

心疼自己的高愛己同學

其實我就是不想聽我的机械鍵盤聲音，實在太吵了

你也知道，筆記本自帶的鍵盤總感覺軟綿綿的，敲起來實在不給力，嚴重影響我的工作效率。那必須得買個鍵盤啊，在多個朋友的推薦下，我就買了一個青軸鍵盤。你別說，觸感真不錯，每按一下，都感覺指尖有一股電流滑過，同時伴隨着啪啪啪的聲音，感覺寫代碼效率明顯變高了，更神奇的是 bug 都比以前少了，你說神奇不。

但是呢，有個缺點，就是時間久了吧，感覺稍微有那麼一點點吵，所以我就配了個耳機，從此之後，既得到了直達靈魂的觸感，又不會感覺吵了。更神奇的一點是，以前罵我的同事好像都不罵我了。

真的在聽東西的同學

雖然存在以上幾位同學說的情況，但大多數情況下， 我們是真的在聽東西。比如我，為了聽高品質的，還專門買了網易雲音樂的 VIP 。

為什麼是東西，而不是音樂呢，因為有的人不是在聽音樂。

我聽說有人在寫代碼的時候聽評書，更有厲害的，竟然聽相聲。那我想只有三種可能。

1. 根本沒在寫代碼，可能是在摸魚。
2. 評書一點都不精彩，相聲一點都不好笑，僅僅是一門語言的藝術而已。
3. 這是個大佬，已經進入忘我的境界，聽到的不是語言，而是聲音解析成比特位時產生的白噪音，一般人聽不到，只有某些段位的大佬可以。

當然畢竟大佬不常有，而普通群眾常用。大部分人聽的確實是音樂。比如我吧，我戴耳機真的是在聽音樂，為了降噪、減少干擾，提高專註力，提升效率。

什麼類型的音樂更受程序員歡迎呢

英文歌

英文歌是大多數程序員的最愛。請看網易雲音樂給我的每日歌曲推薦，除了伍佰的一首中文歌亂入，剩下的都是英文歌。

你真的認為我英語很好嗎，正好相反，之所以英文歌那麼受歡迎，就是因為聽不懂歌詞是什麼意思，這樣才不會被歌詞帶跑偏，沒錯，我們聽的就是這個節奏。

那要是中文歌就不一樣了，比如說當我聽到「你的酒館對我打了烊，子彈在我心頭上了膛」的時候，我就以為真的要打烊了，子彈真的要上膛了，從而引發一系列思考，酒館為什麼對我打烊，子彈為什麼要上膛，生意不做了嗎，刑法基本法則不懂嗎。

為了證明這一點，我到網易雲音樂上搜了「程序員」相關的歌單，點進去一看，大部分也都是英文歌，看來大家英文都不太好。

然後我又搜了「產品狗」相關的歌單，同樣也是英文歌為主，可見我們雖然不太對付，請參考歌單『產品狗如何說服程序猿』和『程序員如何回應產品狗』，但是方法論還是差不多的。

純音樂

純音樂也是很受歡迎的，我有個同事最喜歡聽貝多芬的命運交響曲，我就沒那麼文藝了。我一般都是聽那種激昂的小提琴或者聽完感覺自己馬上要登基了的那種，不容易犯困。

白噪音

小提琴太勁爆，不能常聽，犯困的下午聽聽可以提神，bug 太多又不想改的時候可以聽聽。大多數時候，不需要那麼亢奮，保持內心的平靜就是寫代碼最好的狀態。那就聽聽白噪音好了，比如雨聲、風聲、溪水聲、鳥唱蟬鳴。

我最喜歡的就是雨聲，嘩啦啦的大雨，再配上驚雷，簡直不要太平靜，innerpeace。

比如下面這個，一聽就是一個小時。

保留曲目

每個人都有自己家私藏的歌單，百聽不厭的那種，當然每個人的品位不一樣、口味兒不一樣，比如當年有個哥們兒異常興奮的把他的珍藏歌單分享給我，我當即表示很感動，一定要認真聽一聽。可當我硬着頭皮聽完第二首的時候，我內心是拒絕的，只能委婉的跟哥們兒說：這 TM 什麼玩意兒。當然是不會破壞友誼的小船的，如果是不熟的朋友，那肯定會豎起大拇指，並且連連點頭稱讚：真不錯，品位棒棒噠。

我沒有薦歌啊，向別人推薦歌曲犹如喂別人食物，你覺得好吃別人並一定覺得好吃。下面是我的 2018 年年度聽歌報告，Sophie Zelmani（蘇菲.珊曼妮）的熱門50單曲就是我的保留曲目，白聽不厭，而且更重要的不仔細聽，還是聽不出歌詞的意思，正好適合寫代碼用。

另外，作為一個程序員鼓勵師，為了鼓勵我自己，我也創建了一個「程序員鼓勵師」的歌單，經常拿出來聽聽接收鼓勵。

作為程序員的你，耳機里有什麼特殊的內容嗎？

壯士且慢，先給點個贊吧，總是被白嫖，身體吃不消！

我是風箏，公眾號「古時的風箏」。一個兼具深度與廣度的程序員鼓勵師，一個本打算寫詩卻寫起了代碼的田園碼農！你可選擇現在就關注我，或者看看歷史文章再關注也不遲。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案