創建線程 執行 過程 data- body javase 接下來 而後 定義

通過前面幾篇的學習，我們知道創建線程的方式有兩種，一種是實現Runnable接口，另一種是繼承Thread，但是這兩種方式都有個缺點，那就是在任務執行完成之後無法獲取返回結果，那如果我們想要獲取返回結果該如何實現呢？還記上一篇Executor框架結構中提到的Callable接口和Future接口嗎？，是的，從Java SE 5.0開始引入了Callable和Future，通過它們構建的線程，在任務執行完成後就可以獲取執行結果，今天我們就來聊聊線程創建的第三種方式，那就是實現Callable接口。

1.Callable<V>接口 我們先回顧一下java.lang.Runnable接口，就聲明了run(),其返回值為void，當然就無法獲取結果了。 [java] view plain copy print?

1. public interface Runnable {
2. public abstract void run();
3. }

而Callable的接口定義如下

[java] view plain copy print?

1. public interface Callable<V> {
2. V call() throws Exception;
3. }

該接口聲明了一個名稱為call()的方法，同時這個方法可以有返回值V，也可以拋出異常。嗯，對該接口我們先了解這麽多就行，下面我們來說明如何使用，前篇文章我們說過，無論是Runnable接口的實現類還是Callable接口的實現類，都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor執行，ThreadPoolExecutor或ScheduledThreadPoolExecutor都實現了ExcutorService接口，而因此Callable需要和Executor框架中的ExcutorService結合使用，我們先看看ExecutorService提供的方法：

[java] view plain copy print?

1. <T> Future<T> submit(Callable<T> task);
2. <T> Future<T> submit(Runnable task, T result);
3. Future<?> submit(Runnable task);

第一個方法：submit提交一個實現Callable接口的任務，並且返回封裝了異步計算結果的Future。 第二個方法：submit提交一個實現Runnable接口的任務，並且指定了在調用Future的get方法時返回的result對象。 第三個方法：submit提交一個實現Runnable接口的任務，並且返回封裝了異步計算結果的Future。 因此我們只要創建好我們的線程對象（實現Callable接口或者Runnable接口），然後通過上面3個方法提交給線程池去執行即可。還有點要註意的是，除了我們自己實現Callable對象外，我們還可以使用工廠類Executors來把一個Runnable對象包裝成Callable對象。Executors工廠類提供的方法如下： [java] view plain copy print?

1. public static Callable<Object> callable(Runnable task)
2. public static <T> Callable<T> callable(Runnable task, T result)

2.Future<V>接口 Future<V>接口是用來獲取異步計算結果的，說白了就是對具體的Runnable或者Callable對象任務執行的結果進行獲取(get()),取消(cancel()),判斷是否完成等操作。我們看看Future接口的源碼： [java] view plain copy print?

1. public interface Future<V> {
2. boolean cancel(boolean mayInterruptIfRunning);
3. boolean isCancelled();
4. boolean isDone();
5. V get() throws InterruptedException, ExecutionException;
6. V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
7. }

方法解析： V get() ：獲取異步執行的結果，如果沒有結果可用，此方法會阻塞直到異步計算完成。 V get(Long timeout , TimeUnit unit) ：獲取異步執行結果，如果沒有結果可用，此方法會阻塞，但是會有時間限制，如果阻塞時間超過設定的timeout時間，該方法將返回null。 boolean isDone() ：如果任務執行結束，無論是正常結束或是中途取消還是發生異常，都返回true。 boolean isCanceller() ：如果任務完成前被取消，則返回true。 boolean cancel(boolean mayInterruptRunning) ：如果任務還沒開始，執行cancel(...)方法將返回false；如果任務已經啟動，執行cancel(true)方法將以中斷執行此任務線程的方式來試圖停止任務，如果停止成功，返回true；當任務已經啟動，執行cancel(false)方法將不會對正在執行的任務線程產生影響(讓線程正常執行到完成)，此時返回false；當任務已經完成，執行cancel(...)方法將返回false。mayInterruptRunning參數表示是否中斷執行中的線程。 通過方法分析我們也知道實際上Future提供了3種功能：（1）能夠中斷執行中的任務（2）判斷任務是否執行完成（3）獲取任務執行完成後額結果。 但是我們必須明白Future只是一個接口，我們無法直接創建對象，因此就需要其實現類FutureTask登場啦。 3.FutureTask類 我們先來看看FutureTask的實現 [java] view plain copy print?

1. public class FutureTask<V> implements RunnableFuture<V> {

FutureTask類實現了RunnableFuture接口，我們看一下RunnableFuture接口的實現： [java] view plain copy print?

1. public interface RunnableFuture<V> extends Runnable, Future<V> {
2. void run();
3. }

分析：FutureTask除了實現了Future接口外還實現了Runnable接口，因此FutureTask也可以直接提交給Executor執行。 當然也可以調用線程直接執行（FutureTask.run()）。接下來我們根據FutureTask.run()的執行時機來分析其所處的3種狀態： （1）未啟動，FutureTask.run()方法還沒有被執行之前，FutureTask處於未啟動狀態，當創建一個FutureTask，而且沒有執行FutureTask.run()方法前，這個FutureTask也處於未啟動狀態。 （2）已啟動，FutureTask.run()被執行的過程中，FutureTask處於已啟動狀態。 （3）已完成，FutureTask.run()方法執行完正常結束，或者被取消或者拋出異常而結束，FutureTask都處於完成狀態。
下面我們再來看看FutureTask的方法執行示意圖（方法和Future接口基本是一樣的，這裏就不過多描述了）
分析： （1）當FutureTask處於未啟動或已啟動狀態時，如果此時我們執行FutureTask.get()方法將導致調用線程阻塞；當FutureTask處於已完成狀態時，執行FutureTask.get()方法將導致調用線程立即返回結果或者拋出異常。 （2）當FutureTask處於未啟動狀態時，執行FutureTask.cancel()方法將導致此任務永遠不會執行。 當FutureTask處於已啟動狀態時，執行cancel(true)方法將以中斷執行此任務線程的方式來試圖停止任務，如果任務取消成功，cancel(...)返回true；但如果執行cancel(false)方法將不會對正在執行的任務線程產生影響(讓線程正常執行到完成)，此時cancel(...)返回false。 當任務已經完成，執行cancel(...)方法將返回false。 最後我們給出FutureTask的兩種構造函數： [java] view plain copy print?

1. public FutureTask(Callable<V> callable) {
2. }
3. public FutureTask(Runnable runnable, V result) {
4. }

3.Callable<V>/Future<V>/FutureTask的使用 通過上面的介紹，我們對Callable，Future，FutureTask都有了比較清晰的了解了，那麽它們到底有什麽用呢？我們前面說過通過這樣的方式去創建線程的話，最大的好處就是能夠返回結果，加入有這樣的場景，我們現在需要計算一個數據，而這個數據的計算比較耗時，而我們後面的程序也要用到這個數據結果，那麽這個時Callable豈不是最好的選擇？我們可以開設一個線程去執行計算，而主線程繼續做其他事，而後面需要使用到這個數據時，我們再使用Future獲取不就可以了嗎？下面我們就來編寫一個這樣的實例 3.1 使用Callable+Future獲取執行結果 Callable實現類如下： [java] view plain copy print?

1. package com.zejian.Executor;
2. import java.util.concurrent.Callable;
3. /**
4. * @author zejian
5. * @time 2016年3月15日 下午2:02:42
6. * @decrition Callable接口實例
7. */
8. public class CallableDemo implements Callable<Integer> {
10. private int sum;
11. @Override
12. public Integer call() throws Exception {
13. System.out.println("Callable子線程開始計算啦！");
14. Thread.sleep(2000);
16. for(int i=0 ;i<5000;i++){
17. sum=sum+i;
18. }
19. System.out.println("Callable子線程計算結束！");
20. return sum;
21. }
22. }

Callable執行測試類如下：

[java] view plain copy print?

1. package com.zejian.Executor;
2. import java.util.concurrent.ExecutorService;
3. import java.util.concurrent.Executors;
4. import java.util.concurrent.Future;
5. /**
6. * @author zejian
7. * @time 2016年3月15日 下午2:05:43
8. * @decrition callable執行測試類
9. */
10. public class CallableTest {
12. public static void main(String[] args) {
13. //創建線程池
14. ExecutorService es = Executors.newSingleThreadExecutor();
15. //創建Callable對象任務
16. CallableDemo calTask=new CallableDemo();
17. //提交任務並獲取執行結果
18. Future<Integer> future =es.submit(calTask);
19. //關閉線程池
20. es.shutdown();
21. try {
22. Thread.sleep(2000);
23. System.out.println("主線程在執行其他任務");
25. if(future.get()!=null){
26. //輸出獲取到的結果
27. System.out.println("future.get()-->"+future.get());
28. }else{
29. //輸出獲取到的結果
30. System.out.println("future.get()未獲取到結果");
31. }
33. } catch (Exception e) {
34. e.printStackTrace();
35. }
36. System.out.println("主線程在執行完成");
37. }
38. }

執行結果：

Callable子線程開始計算啦！ 主線程在執行其他任務 Callable子線程計算結束！ future.get()-->12497500 主線程在執行完成

3.2 使用Callable+FutureTask獲取執行結果 [java] view plain copy print?

1. package com.zejian.Executor;
2. import java.util.concurrent.ExecutorService;
3. import java.util.concurrent.Executors;
4. import java.util.concurrent.Future;
5. import java.util.concurrent.FutureTask;
6. /**
7. * @author zejian
8. * @time 2016年3月15日 下午2:05:43
9. * @decrition callable執行測試類
10. */
11. public class CallableTest {
13. public static void main(String[] args) {
14. // //創建線程池
15. // ExecutorService es = Executors.newSingleThreadExecutor();
16. // //創建Callable對象任務
17. // CallableDemo calTask=new CallableDemo();
18. // //提交任務並獲取執行結果
19. // Future<Integer> future =es.submit(calTask);
20. // //關閉線程池
21. // es.shutdown();
23. //創建線程池
24. ExecutorService es = Executors.newSingleThreadExecutor();
25. //創建Callable對象任務
26. CallableDemo calTask=new CallableDemo();
27. //創建FutureTask
28. FutureTask<Integer> futureTask=new FutureTask<>(calTask);
29. //執行任務
30. es.submit(futureTask);
31. //關閉線程池
32. es.shutdown();
33. try {
34. Thread.sleep(2000);
35. System.out.println("主線程在執行其他任務");
37. if(futureTask.get()!=null){
38. //輸出獲取到的結果
39. System.out.println("futureTask.get()-->"+futureTask.get());
40. }else{
41. //輸出獲取到的結果
42. System.out.println("futureTask.get()未獲取到結果");
43. }
45. } catch (Exception e) {
46. e.printStackTrace();
47. }
48. System.out.println("主線程在執行完成");
49. }
50. }

執行結果：

Callable子線程開始計算啦！ 主線程在執行其他任務 Callable子線程計算結束！ futureTask.get()-->12497500 主線程在執行完成

Java多線程編程：Callable、Future和FutureTask淺析