本篇內(nèi)容介紹了“并發(fā)編程之如何理解Future&FutureTask”的有關(guān)知識，在實(shí)際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領(lǐng)大家學(xué)習(xí)一下如何處理這些情況吧！希望大家仔細(xì)閱讀，能夠?qū)W有所成！
成都創(chuàng)新互聯(lián)公司網(wǎng)站建設(shè)提供從項(xiàng)目策劃、軟件開發(fā)，軟件安全維護(hù)、網(wǎng)站優(yōu)化(SEO)、網(wǎng)站分析、效果評估等整套的建站服務(wù)，主營業(yè)務(wù)為成都網(wǎng)站建設(shè)、網(wǎng)站制作，手機(jī)APP定制開發(fā)以傳統(tǒng)方式定制建設(shè)網(wǎng)站，并提供域名空間備案等一條龍服務(wù)，秉承以專業(yè)、用心的態(tài)度為用戶提供真誠的服務(wù)。成都創(chuàng)新互聯(lián)公司深信只要達(dá)到每一位用戶的要求，就會得到認(rèn)可，從而選擇與我們長期合作。這樣，我們也可以走得更遠(yuǎn)！
前言
Java線程實(shí)現(xiàn)方式主要有四種：
繼承Thread類
實(shí)現(xiàn)Runnable接口
實(shí)現(xiàn)Callable接口通過FutureTask包裝器來創(chuàng)建Thread線程
使用ExecutorService、Callable、Future實(shí)現(xiàn)有返回結(jié)果的多線程。
其中前兩種方式線程執(zhí)行完后都沒有返回值，后兩種是帶返回值的。
Callable 和 Runnable 接口
Runnable接口
重慶分公司
重慶分公司
// 實(shí)現(xiàn)Runnable接口的類將被Thread執(zhí)行，表示一個(gè)基本的任務(wù) public interface Runnable { // run方法就是它所有的內(nèi)容，就是實(shí)際執(zhí)行的任務(wù) public abstract void run(); }沒有返回值
run 方法沒有返回值，雖然有一些別的方法也能實(shí)現(xiàn)返回值得效果，比如編寫日志文件或者修改共享變量等等，但是不僅容易出錯，效率也不高。
不能拋出異常
public class RunThrowExceptionDemo { /** * 普通方法可以在方法簽名中拋出異常 * * @throws IOException */ public void normalMethod() throws IOException { throw new IOException(); } class RunnableImpl implements Runnable { /** * run 方法內(nèi)無法拋出 checked Exception，除非使用 try catch 進(jìn)行處理 */ @Override public void run() { try { throw new IOException(); } catch (IOException e) { e.printStackTrace(); } } } }可以看到普通方法 normalMethod 可以在方法簽名上拋出異常，這樣上層接口就可以捕獲這個(gè)異常進(jìn)行處理，但是實(shí)現(xiàn) Runnable 接口的類，run 方法無法拋出 checked Exception，只能在方法內(nèi)使用 try catch 進(jìn)行處理，這樣上層就無法得知線程中的異常。
設(shè)計(jì)導(dǎo)致
其實(shí)這兩個(gè)缺陷主要原因就在于 Runnable 接口設(shè)計(jì)的 run 方法，這個(gè)方法已經(jīng)規(guī)定了 run() 方法的返回類型是 void，而且這個(gè)方法沒有聲明拋出任何異常。所以，當(dāng)實(shí)現(xiàn)并重寫這個(gè)方法時(shí)，我們既不能改返回值類型，也不能更改對于異常拋出的描述，因?yàn)樵趯?shí)現(xiàn)方法的時(shí)候，語法規(guī)定是不允許對這些內(nèi)容進(jìn)行修改的。
Runnable 為什么設(shè)計(jì)成這樣?
假設(shè) run() 方法可以返回返回值，或者可以拋出異常，也無濟(jì)于事，因?yàn)槲覀儾]有辦法在外層捕獲并處理，這是因?yàn)檎{(diào)用 run() 方法的類(比如 Thread 類和線程池)是 Java 直接提供的，而不是我們編寫的。 所以就算它能有一個(gè)返回值，我們也很難把這個(gè)返回值利用到，而 Callable 接口就是為了解決這兩個(gè)問題。
Callable接口
public interface Callable{ //返回接口，或者拋出異常 V call() throws Exception; }
可以看到 Callable 和 Runnable 接口其實(shí)比較相似，都只有一個(gè)方法，也就是線程任務(wù)執(zhí)行的方法，區(qū)別就是 call 方法有返回值，而且聲明了 throws Exception。
Callable 和 Runnable 的不同之處
方法名：Callable 規(guī)定的執(zhí)行方法是 call()，而 Runnable 規(guī)定的執(zhí)行方法是 run();
返回值：Callable 的任務(wù)執(zhí)行后有返回值，而 Runnable 的任務(wù)執(zhí)行后是沒有返回值的;
拋出異常：call() 方法可拋出異常，而 run() 方法是不能拋出受檢查異常的;
與 Callable 配合的有一個(gè) Future 接口，通過 Future 可以了解任務(wù)執(zhí)行情況，或者取消任務(wù)的執(zhí)行，還可獲取任務(wù)執(zhí)行的結(jié)果，這些功能都是 Runnable 做不到的，Callable 的功能要比 Runnable 強(qiáng)大。
Future接口
Future的作用
簡單來說就是利用線程達(dá)到異步的效果，同時(shí)還可以獲取子線程的返回值。
比如當(dāng)做一定運(yùn)算的時(shí)候，運(yùn)算過程可能比較耗時(shí)，有時(shí)會去查數(shù)據(jù)庫，或是繁重的計(jì)算，比如壓縮、加密等，在這種情況下，如果我們一直在原地等待方法返回，顯然是不明智的，整體程序的運(yùn)行效率會大大降低。
我們可以把運(yùn)算的過程放到子線程去執(zhí)行，再通過 Future 去控制子線程執(zhí)行的計(jì)算過程，最后獲取到計(jì)算結(jié)果。這樣一來就可以把整個(gè)程序的運(yùn)行效率提高，是一種異步的思想。
Future的方法
Future 接口一共有5個(gè)方法，源代碼如下：
public interface Future{ /** * 嘗試取消任務(wù)，如果任務(wù)已經(jīng)完成、已取消或其他原因無法取消，則失敗。 * 1、如果任務(wù)還沒開始執(zhí)行，則該任務(wù)不應(yīng)該運(yùn)行 * 2、如果任務(wù)已經(jīng)開始執(zhí)行，由參數(shù)mayInterruptIfRunning來決定執(zhí)行該任務(wù)的線程是否應(yīng)該被中斷，這只是終止任務(wù)的一種嘗試。若mayInterruptIfRunning為true，則會立即中斷執(zhí)行任務(wù)的線程并返回true，若mayInterruptIfRunning為false，則會返回true且不會中斷任務(wù)執(zhí)行線程。 * 3、調(diào)用這個(gè)方法后，以后對isDone方法調(diào)用都返回true。 * 4、如果這個(gè)方法返回true,以后對isCancelled返回true。 */ boolean cancel(boolean mayInterruptIfRunning); /** * 判斷任務(wù)是否被取消了，如果調(diào)用了cance()則返回true */ boolean isCancelled(); /** * 如果任務(wù)完成，則返回ture * 任務(wù)完成包含正常終止、異常、取消任務(wù)。在這些情況下都返回true */ boolean isDone(); /** * 線程阻塞，直到任務(wù)完成，返回結(jié)果 * 如果任務(wù)被取消，則引發(fā)CancellationException * 如果當(dāng)前線程被中斷，則引發(fā)InterruptedException * 當(dāng)任務(wù)在執(zhí)行的過程中出現(xiàn)異常，則拋出ExecutionException */ V get() throws InterruptedException, ExecutionException; /** * 線程阻塞一定時(shí)間等待任務(wù)完成，并返回任務(wù)執(zhí)行結(jié)果，如果則超時(shí)則拋出TimeoutException */ V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }
get方法(獲取結(jié)果)
get 方法最主要的作用就是獲取任務(wù)執(zhí)行的結(jié)果，該方法在執(zhí)行時(shí)的行為取決于 Callable 任務(wù)的狀態(tài)，可能會發(fā)生以下 7 種情況。
任務(wù)已經(jīng)執(zhí)行完，執(zhí)行 get 方法可以立刻返回，獲取到任務(wù)執(zhí)行的結(jié)果。
任務(wù)還沒有開始執(zhí)行，比如我們往線程池中放一個(gè)任務(wù)，線程池中可能積壓了很多任務(wù)，還沒輪到我去執(zhí)行的時(shí)候，就去 get 了，在這種情況下，相當(dāng)于任務(wù)還沒開始，我們?nèi)フ{(diào)用 get 的時(shí)候，會當(dāng)前的線程阻塞，直到任務(wù)完成再把結(jié)果返回回來。
任務(wù)正在執(zhí)行中，但是執(zhí)行過程比較長，所以我去 get 的時(shí)候，它依然在執(zhí)行的過程中。這種情況調(diào)用 get 方法也會阻塞當(dāng)前線程，直到任務(wù)執(zhí)行完返回結(jié)果。
任務(wù)執(zhí)行過程中拋出異常，我們再去調(diào)用 get 的時(shí)候，就會拋出 ExecutionException 異常，不管我們執(zhí)行 call 方法時(shí)里面拋出的異常類型是什么，在執(zhí)行 get 方法時(shí)所獲得的異常都是 ExecutionException。
任務(wù)被取消了，如果任務(wù)被取消，我們用 get 方法去獲取結(jié)果時(shí)則會拋出 CancellationException。
任務(wù)被中斷了，如果任務(wù)被當(dāng)前線程中斷，我們用 get 方法去獲取結(jié)果時(shí)則會拋出InterruptedException。
任務(wù)超時(shí)，我們知道 get 方法有一個(gè)重載方法，那就是帶延遲參數(shù)的，調(diào)用了這個(gè)帶延遲參數(shù)的 get 方法之后，如果 call 方法在規(guī)定時(shí)間內(nèi)正常順利完成了任務(wù)，那么 get 會正常返回;但是如果到達(dá)了指定時(shí)間依然沒有完成任務(wù)，get 方法則會拋出 TimeoutException，代表超時(shí)了。
參考示例：
package com.niuh.future; import java.util.Random; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; public class FutureDemo { public static void main(String[] args) { ExecutorService executorService = Executors.newSingleThreadExecutor(); Future future = executorService.submit(new FutureTask()); try { Integer res = future.get(2000, TimeUnit.MILLISECONDS); System.out.println("Future線程返回值：" + res); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } catch (TimeoutException e) { e.printStackTrace(); } } static class FutureTask implements Callable { @Override public Integer call() throws Exception { Thread.sleep(new Random().nextInt(3000)); return new Random().nextInt(10); } } } isDone方法(判斷是否執(zhí)行完畢)
isDone() 方法，該方法是用來判斷當(dāng)前這個(gè)任務(wù)是否執(zhí)行完畢了
package com.niuh.future; import java.util.Random; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; public class FutureIsDoneDemo { public static void main(String[] args) { ExecutorService executorService = Executors.newSingleThreadExecutor(); Future future = executorService.submit(new FutureTask()); try { for (int i = 0; i < 3; i++) { Thread.sleep(1000); System.out.println("線程是否完成：" + future.isDone()); } Integer res = future.get(2000, TimeUnit.MILLISECONDS); System.out.println("Future 線程返回值：" + res); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } catch (TimeoutException e) { e.printStackTrace(); } } static class FutureTask implements Callable { @Override public Integer call() throws Exception { Thread.sleep(2000); return new Random().nextInt(10); } } } 執(zhí)行結(jié)果：
線程是否完成：false 線程是否完成：false 線程是否完成：true Future 線程返回值：9
可以看到前兩次 isDone 方法的返回結(jié)果是 false，因?yàn)榫€程任務(wù)還沒有執(zhí)行完成，第三次 isDone 方法的返回結(jié)果是 ture。
注意：這個(gè)方法返回 true 則代表執(zhí)行完成了，返回 false 則代表還沒完成。但返回 true，并不代表這個(gè)任務(wù)是成功執(zhí)行的，比如說任務(wù)執(zhí)行到一半拋出了異常。那么在這種情況下，對于這個(gè) isDone 方法而言，它其實(shí)也是會返回 true 的，因?yàn)閷λ鼇碚f，雖然有異常發(fā)生了，但是這個(gè)任務(wù)在未來也不會再被執(zhí)行，它確實(shí)已經(jīng)執(zhí)行完畢了。所以 isDone 方法在返回 true 的時(shí)候，不代表這個(gè)任務(wù)是成功執(zhí)行的，只代表它執(zhí)行完畢了。
我們將上面的示例稍作修改再來看下結(jié)果，修改 FutureTask 代碼如下：
static class FutureTask implements Callable{ @Override public Integer call() throws Exception { Thread.sleep(2000); throw new Exception("故意拋出異常"); } }
執(zhí)行結(jié)果：
雖然拋出了異常，但是 isDone 方法的返回結(jié)果依然是 ture。
這段代碼說明了：
即便任務(wù)拋出異常，isDone 方法依然會返回 true。
雖然拋出的異常是 IllegalArgumentException，但是對于 get 而言，它拋出的異常依然是 ExecutionException。
雖然在任務(wù)執(zhí)行到2秒的時(shí)候就拋出了異常，但是真正要等到我們執(zhí)行 get 的時(shí)候，才看到了異常。
cancel方法(取消任務(wù)的執(zhí)行)
如果不想執(zhí)行某個(gè)任務(wù)了，則可以使用 cancel 方法，會有以下三種情況：
第一種情況最簡單，那就是當(dāng)任務(wù)還沒有開始執(zhí)行時(shí)，一旦調(diào)用 cancel，這個(gè)任務(wù)就會被正常取消，未來也不會被執(zhí)行，那么 cancel 方法返回 true。
第二種情況也比較簡單。如果任務(wù)已經(jīng)完成，或者之前已經(jīng)被取消過了，那么執(zhí)行 cancel 方法則代表取消失敗，返回 false。因?yàn)槿蝿?wù)無論是已完成還是已經(jīng)被取消過了，都不能再被取消了。
第三種情況比較特殊，就是這個(gè)任務(wù)正在執(zhí)行，這個(gè)時(shí)候執(zhí)行 cancel 方法是不會直接取消這個(gè)任務(wù)的，而是會根據(jù)我們傳入的參數(shù)做判斷。cancel 方法是必須傳入一個(gè)參數(shù)，該參數(shù)叫作 mayInterruptIfRunning，它是什么含義呢?如果傳入的參數(shù)是 true，執(zhí)行任務(wù)的線程就會收到一個(gè)中斷的信號，正在執(zhí)行的任務(wù)可能會有一些處理中斷的邏輯，進(jìn)而停止，這個(gè)比較好理解。如果傳入的是 false 則就代表不中斷正在運(yùn)行的任務(wù)，也就是說，本次 cancel 不會有任何效果，同時(shí) cancel 方法會返回 false。
參考示例：
package com.niuh.future; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; public class FutureCancelDemo { static ExecutorService executorService = Executors.newSingleThreadExecutor(); public static void main(String[] args) { // 當(dāng)任務(wù)還沒有開始執(zhí)行 // demo1(); // 如果任務(wù)已經(jīng)執(zhí)行完 // demo2(); // 如果任務(wù)正在進(jìn)行中 demo3(); } private static void demo1() { for (int i = 0; i < 1000; i++) { executorService.submit(new FutureTask()); } Future future = executorService.submit(new FutureTask()); try { boolean cancel = future.cancel(false); System.out.println("Future 任務(wù)是否被取消：" + cancel); String res = future.get(2000, TimeUnit.MILLISECONDS); System.out.println("Future 線程返回值：" + res); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } catch (TimeoutException e) { e.printStackTrace(); } finally { executorService.shutdown(); } } private static void demo2() { Future future = executorService.submit(new FutureTask()); try { Thread.sleep(1000); boolean cancel = future.cancel(false); System.out.println("Future 任務(wù)是否被取消：" + cancel); } catch (InterruptedException e) { e.printStackTrace(); } finally { executorService.shutdown(); } } private static void demo3() { Future future = executorService.submit(new FutureInterruptTask()); try { Thread.sleep(1000); boolean cancel = future.cancel(true); System.out.println("Future 任務(wù)是否被取消：" + cancel); } catch (InterruptedException e) { e.printStackTrace(); } finally { executorService.shutdown(); } } static class FutureTask implements Callable { @Override public String call() throws Exception { return "正常返回"; } } static class FutureInterruptTask implements Callable { @Override public String call() throws Exception { while (!Thread.currentThread().isInterrupted()) { System.out.println("循環(huán)執(zhí)行"); Thread.sleep(500); } System.out.println("線程被中斷"); return "正常返回"; } } } 這里，我們來分析下第三種情況(任務(wù)正在進(jìn)行中)，當(dāng)我們設(shè)置 true 時(shí)，線程停止
循環(huán)執(zhí)行 循環(huán)執(zhí)行 Future 任務(wù)是否被取消：true
當(dāng)我們設(shè)置 false 時(shí)，任務(wù)雖然也被取消成功，但是線程依然執(zhí)行。
循環(huán)執(zhí)行 循環(huán)執(zhí)行 Future 任務(wù)是否被取消：true 循環(huán)執(zhí)行 循環(huán)執(zhí)行 循環(huán)執(zhí)行 循環(huán)執(zhí)行 ......
那么如何選擇傳入 true 還是 false 呢?
傳入 true 適用的情況是，明確知道這個(gè)任務(wù)能夠處理中斷。
傳入 false 適用于什么情況呢?如果我們明確知道這個(gè)線程不能處理中斷，那應(yīng)該傳入 false。我們不知道這個(gè)任務(wù)是否支持取消(是否能響應(yīng)中斷)，因?yàn)樵诖蠖鄶?shù)情況下代碼是多人協(xié)作的，對于這個(gè)任務(wù)是否支持中斷，我們不一定有十足的把握，那么在這種情況下也應(yīng)該傳入 false。如果這個(gè)任務(wù)一旦開始運(yùn)行，我們就希望它完全的執(zhí)行完畢。在這種情況下，也應(yīng)該傳入 false。
需要注意的是，雖然示例中寫了 !Thread.currentThread().isInterrupted() 方法來判斷中斷，但是實(shí)際上并不是通過我們的代碼來進(jìn)行中斷，而是 Future#cancel(true) 內(nèi)部調(diào)用 t.interrupt 方法修改線程的狀態(tài)之后，Thread.sleep 會拋出 InterruptedException 異常，線程池中會執(zhí)行異常的相關(guān)邏輯，并退出當(dāng)前任務(wù)。 sleep 和 interrupt 會產(chǎn)生意想不到的效果。
比如我們將 FutureInterruptTask 代碼修改為 while(true) 形式，調(diào)用 cancel(true) 方法線程還是會被中斷。
static class FutureInterruptTask implements Callable{ @Override public String call() throws Exception { while (true) { System.out.println("循環(huán)執(zhí)行"); Thread.sleep(500); } } }
isCancelled方法(判斷是否被取消)
isCancelled 方法，判斷是否被取消，它和 cancel 方法配合使用，比較簡單，可以參考上面的示例。
Callable 和 Future 的關(guān)系
Callable 接口相比于 Runnable 的一大優(yōu)勢是可以有返回結(jié)果，返回結(jié)果就可以用 Future 類的 get 方法來獲取 。因此，F(xiàn)uture 相當(dāng)于一個(gè)存儲器，它存儲了 Callable 的 call 方法的任務(wù)結(jié)果。
除此之外，我們還可以通過 Future 的 isDone 方法來判斷任務(wù)是否已經(jīng)執(zhí)行完畢了，還可以通過 cancel 方法取消這個(gè)任務(wù)，或限時(shí)獲取任務(wù)的結(jié)果等，總之 Future 的功能比較豐富。
FutureTask
Future只是一個(gè)接口，不能直接用來創(chuàng)建對象，其實(shí)現(xiàn)類是FutureTask，JDK1.8修改了FutureTask的實(shí)現(xiàn)，JKD1.8不再依賴AQS來實(shí)現(xiàn)，而是通過一個(gè)volatile變量state以及CAS操作來實(shí)現(xiàn)。FutureTask結(jié)構(gòu)如下所示：
我們來看一下 FutureTask 的代碼實(shí)現(xiàn)：
public class FutureTask implements RunnableFuture {...}可以看到，它實(shí)現(xiàn)了一個(gè)接口，這個(gè)接口叫作 RunnableFuture。
RunnableFuture接口
我們來看一下 RunnableFuture 接口的代碼實(shí)現(xiàn)：
public interface RunnableFutureextends Runnable, Future { /** * Sets this Future to the result of its computation * unless it has been cancelled. */ void run(); }
既然 RunnableFuture 繼承了 Runnable 接口和 Future 接口，而 FutureTask 又實(shí)現(xiàn)了 RunnableFuture 接口，所以 FutureTask 既可以作為 Runnable 被線程執(zhí)行，又可以作為 Future 得到 Callable 的返回值。
FutureTask源碼分析
成員變量
/* * 當(dāng)前任務(wù)運(yùn)行狀態(tài) * NEW -> COMPLETING -> NORMAL(正常結(jié)束，返回結(jié)果) * NEW -> COMPLETING -> EXCEPTIONAL(返回異常結(jié)果) * NEW -> CANCELLED(任務(wù)被取消，無結(jié)果) * NEW -> INTERRUPTING -> INTERRUPTED(任務(wù)被打斷，無結(jié)果) */ private volatile int state; private static final int NEW = 0; // 新建 0 private static final int COMPLETING = 1; // 執(zhí)行中 1 private static final int NORMAL = 2; // 正常 2 private static final int EXCEPTIONAL = 3; // 異常 3 private static final int CANCELLED = 4; // 取消 4 private static final int INTERRUPTING = 5; // 中斷中 5 private static final int INTERRUPTED = 6; // 被中斷 6 /** 將要被執(zhí)行的任務(wù) */ private Callablecallable; /** 存放執(zhí)行結(jié)果，用于get()方法獲取結(jié)果，也可能用于get()方法拋出異常 */ private Object outcome; // non-volatile, protected by state reads/writes /** 執(zhí)行任務(wù)Callable的線程; */ private volatile Thread runner; /** 棧結(jié)構(gòu)的等待隊(duì)列，該節(jié)點(diǎn)是棧中最頂層的節(jié)點(diǎn) */ private volatile WaitNode waiters;
為了后面更好的分析FutureTask的實(shí)現(xiàn)，這里有必要解釋下各個(gè)狀態(tài)。
NEW：表示是個(gè)新的任務(wù)或者還沒被執(zhí)行完的任務(wù)。這是初始狀態(tài)。
COMPLETING：任務(wù)已經(jīng)執(zhí)行完成或者執(zhí)行任務(wù)的時(shí)候發(fā)生異常，但是任務(wù)執(zhí)行結(jié)果或者異常原因還沒有保存到outcome字段(outcome字段用來保存任務(wù)執(zhí)行結(jié)果，如果發(fā)生異常，則用來保存異常原因)的時(shí)候，狀態(tài)會從NEW變更到COMPLETING。但是這個(gè)狀態(tài)會時(shí)間會比較短，屬于中間狀態(tài)。
NORMAL：任務(wù)已經(jīng)執(zhí)行完成并且任務(wù)執(zhí)行結(jié)果已經(jīng)保存到outcome字段，狀態(tài)會從COMPLETING轉(zhuǎn)換到NORMAL。這是一個(gè)最終態(tài)。
EXCEPTIONAL ：任務(wù)執(zhí)行發(fā)生異常并且異常原因已經(jīng)保存到outcome字段中后，狀態(tài)會從COMPLETING轉(zhuǎn)換到EXCEPTIONAL。這是一個(gè)最終態(tài)。
CANCELLED ：任務(wù)還沒開始執(zhí)行或者已經(jīng)開始執(zhí)行但是還沒有執(zhí)行完成的時(shí)候，用戶調(diào)用了cancel(false)方法取消任務(wù)且不中斷任務(wù)執(zhí)行線程，這個(gè)時(shí)候狀態(tài)會從NEW轉(zhuǎn)化為CANCELLED狀態(tài)。這是一個(gè)最終態(tài)。
INTERRUPTING：任務(wù)還沒開始執(zhí)行或者已經(jīng)執(zhí)行但是還沒有執(zhí)行完成的時(shí)候，用戶調(diào)用了cancel(true)方法取消任務(wù)并且要中斷任務(wù)執(zhí)行線程但是還沒有中斷任務(wù)執(zhí)行線程之前，狀態(tài)會從NEW轉(zhuǎn)化為INTERRUPTING。這是一個(gè)中間狀態(tài)。
INTERRUPTED ：調(diào)用interrupt()中斷任務(wù)執(zhí)行線程之后狀態(tài)會從INTERRUPTING轉(zhuǎn)換到INTERRUPTED。這是一個(gè)最終態(tài)。
有一點(diǎn)需要注意的是，所有值大于COMPLETING的狀態(tài)都表示任務(wù)已經(jīng)執(zhí)行完成(任務(wù)正常執(zhí)行完成，任務(wù)執(zhí)行異?；蛘呷蝿?wù)被取消)。
構(gòu)造方法
// Callable 構(gòu)造方法 public FutureTask(Callablecallable) { if (callable == null) throw new NullPointerException(); this.callable = callable; this.state = NEW; // ensure visibility of callable } // Runnable 構(gòu)造方法 public FutureTask(Runnable runnable, V result) { this.callable = Executors.callable(runnable, result); this.state = NEW; // ensure visibility of callable }
Runnable的構(gòu)造器，只有一個(gè)目的，就是通過Executors.callable把入?yún)⑥D(zhuǎn)化為RunnableAdapter，主要是因?yàn)镃allable的功能比Runnable豐富，Callable有返回值，而Runnable沒有。
/** * A callable that runs given task and returns given result */ static final class RunnableAdapterimplements Callable { final Runnable task; final T result; RunnableAdapter(Runnable task, T result) { this.task = task; this.result = result; } public T call() { task.run(); return result; } }
這是一個(gè)典型的適配模型，我們要把 Runnable 適配成 Callable，首先要實(shí)現(xiàn) Callable 的接口，接著在 Callable 的 call 方法里面調(diào)用被適配對象(Runnable)的方法。
內(nèi)部類
static final class WaitNode { volatile Thread thread; volatile WaitNode next; WaitNode() { thread = Thread.currentThread(); } }run方法
/** * run方法可以直接被調(diào)用 * 也可以開啟新的線程調(diào)用 */ public void run() { // 狀態(tài)不是任務(wù)創(chuàng)建，或者當(dāng)前任務(wù)已經(jīng)有線程在執(zhí)行了，直接返回 if (state != NEW || !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread())) return; try { Callable c = callable; // Callable 不為空，并且已經(jīng)初始化完成 if (c != null && state == NEW) { V result; boolean ran; try { //調(diào)用執(zhí)行 result = c.call(); ran = true; } catch (Throwable ex) { result = null; ran = false;//執(zhí)行失敗 //通過CAS算法設(shè)置返回值(COMPLETING)和狀態(tài)值(EXCEPTIONAL) setException(ex); } //執(zhí)行成功通過CAS(UNSAFE)設(shè)置返回值(COMPLETING)和狀態(tài)值(NORMAL) if (ran) //將result賦值給outcome set(result); } } finally { // runner must be non-null until state is settled to // prevent concurrent calls to run() //將任務(wù)runner設(shè)置為null,避免發(fā)生并發(fā)調(diào)用run()方法 runner = null; // state must be re-read after nulling runner to prevent // leaked interrupts //須重新讀取任務(wù)狀態(tài)，避免不可達(dá)(泄漏)的中斷 int s = state; //確保cancle(ture)操作時(shí)，運(yùn)行中的任務(wù)能接收到中斷指令 if (s >= INTERRUPTING) handlePossibleCancellationInterrupt(s); } } 鴻蒙官方戰(zhàn)略合作共建——HarmonyOS技術(shù)社區(qū)
run方法是沒有返回值的，通過給outcome屬性賦值(set(result)),get時(shí)就能從outcome屬性中拿到返回值。
FutureTask 兩種構(gòu)造器，最終都轉(zhuǎn)化成了 Callable，所以在 run 方法執(zhí)行的時(shí)候，只需要執(zhí)行 Callable 的 call 方法即可，在執(zhí)行 c.call()代碼時(shí)，如果入?yún)⑹?Runnable 的話， 調(diào)用路徑為 c.call() -> RunnableAdapter.call() -> Runnable.run()，如果入?yún)⑹?Callable 的話，直接調(diào)用。
setException(Throwable t)方法
//發(fā)生異常時(shí)，將返回值設(shè)置到outcome(=COMPLETING)中，并更新任務(wù)狀態(tài)(EXCEPTIONAL) protected void setException(Throwable t) { //調(diào)用UNSAFE類封裝的CAS算法，設(shè)置值 if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) { outcome = t; UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state //喚醒因等待返回值而阻塞的線程 finishCompletion(); } }由于篇幅有限，更多源碼解析請查看文章擴(kuò)展鏈接
Future的使用
FutureTask可用于異步獲取執(zhí)行結(jié)果或取消執(zhí)行任務(wù)的場景。通過傳入Runnable或者Callable的任務(wù)給FutureTask，直接調(diào)用其run方法或者放入線程池執(zhí)行，之后可以在外部通過FutureTask的get方法異步獲取執(zhí)行結(jié)果，因此，F(xiàn)utureTask非常適合用于耗時(shí)的計(jì)算，主線程可以在完成自己的任務(wù)后，再去獲取結(jié)果。另外，F(xiàn)utureTask還可以確保即使調(diào)用了多次run方法，它都只會執(zhí)行一次Runnable或者Callable任務(wù)，或者通過cancel取消FutureTask的執(zhí)行等。
FutureTask執(zhí)行多任務(wù)計(jì)算的使用場景
利用FutureTask和ExecutorService，可以用多線程的方式提交計(jì)算任務(wù)，主線程繼續(xù)執(zhí)行其他任務(wù)，當(dāng)主線程需要子線程的計(jì)算結(jié)果時(shí)，在異步獲取子線程的執(zhí)行結(jié)果。
//任務(wù)正常完成，將返回值設(shè)置到outcome(=COMPLETING)中，并更新任務(wù)狀態(tài)(=NORMAL) protected void set(V v) { if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) { outcome = v; UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state finishCompletion(); } }執(zhí)行結(jié)果：
生成子線程計(jì)算任務(wù): 0 生成子線程計(jì)算任務(wù): 1 生成子線程計(jì)算任務(wù): 2 生成子線程計(jì)算任務(wù): 3 生成子線程計(jì)算任務(wù): 4 生成子線程計(jì)算任務(wù): 5 生成子線程計(jì)算任務(wù): 6 生成子線程計(jì)算任務(wù): 7 生成子線程計(jì)算任務(wù): 8 生成子線程計(jì)算任務(wù): 9 所有計(jì)算任務(wù)提交完畢, 主線程接著干其他事情！ 子線程計(jì)算任務(wù): 0 執(zhí)行完成! 子線程計(jì)算任務(wù): 1 執(zhí)行完成! 子線程計(jì)算任務(wù): 3 執(zhí)行完成! 子線程計(jì)算任務(wù): 4 執(zhí)行完成! 子線程計(jì)算任務(wù): 2 執(zhí)行完成! 子線程計(jì)算任務(wù): 5 執(zhí)行完成! 子線程計(jì)算任務(wù): 7 執(zhí)行完成! 子線程計(jì)算任務(wù): 9 執(zhí)行完成! 子線程計(jì)算任務(wù): 8 執(zhí)行完成! 子線程計(jì)算任務(wù): 6 執(zhí)行完成! 多任務(wù)計(jì)算后的總結(jié)果是:990
FutureTask在高并發(fā)環(huán)境下確保任務(wù)只執(zhí)行一次
在很多高并發(fā)的環(huán)境下，往往我們只需要某些任務(wù)只執(zhí)行一次。這種使用情景FutureTask的特性恰能勝任。舉一個(gè)例子，假設(shè)有一個(gè)帶key的連接池，當(dāng)key存在時(shí)，即直接返回key對應(yīng)的對象;當(dāng)key不存在時(shí)，則創(chuàng)建連接。對于這樣的應(yīng)用場景，通常采用的方法為使用一個(gè)Map對象來存儲key和連接池對應(yīng)的對應(yīng)關(guān)系，典型的代碼如下面所示：
//移除所有等待線程并發(fā)出信號，調(diào)用done（），以及將任務(wù)callable清空 private void finishCompletion() { // assert state > COMPLETING; for (WaitNode q; (q = waiters) != null;) { if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) { //循環(huán)喚醒阻塞線程，直到阻塞隊(duì)列為空 for (;;) { Thread t = q.thread; if (t != null) { q.thread = null; LockSupport.unpark(t); } WaitNode next = q.next; //一直到阻塞隊(duì)列為空，跳出循環(huán) if (next == null) break; q.next = null; // unlink to help gc 方便gc在適當(dāng)?shù)臅r(shí)候回收 q = next; } break; } } done(); callable = null; // to reduce footprint }在上面的例子中，我們通過加鎖確保高并發(fā)環(huán)境下的線程安全，也確保了connection只創(chuàng)建一次，然而卻犧牲了性能。改用ConcurrentHash的情況下，幾乎可以避免加鎖的操作，性能大大提高。
