在再度溫習Java5的並發編程的知識點時發現，首要的就是把Runnable、Callable、Executor、Future等的關系搞明白，遂有了下述小測試程序，通過這個例子上述三者的關系就一目了然了。

在java5以後，一個可以調度執行的線程單元可以有三種方式定義：

Thread、Runnable、Callable，其中Runnable實現的是void run()方法，Callable實現的是 V call()方法，並且可以返回執行結果，其中Runnable可以提交給Thread來包裝下，直接啟動一個線程來執行，而Callable則一般都是提交給ExecuteService來執行。

簡單來說，Executor就是Runnable和Callable的調度容器，Future就是對於具體的調度任務的執行結果進行查看，最為關鍵的是Future可以檢查對應的任務是否已經完成，也可以阻塞在get方法上一直等待任務返回結果。Runnable和Callable的差別就是Runnable是沒有結果可以返回的，就算是通過Future也看不到任務調度的結果的。

1. /**
2. * 通過簡單的測試程序來試驗Runnable、Callable通過Executor來調度的時候與Future的關系
3. */
4. package com.hadoop.thread;
6. import java.util.concurrent.Callable;
7. import java.util.concurrent.ExecutorService;
8. import java.util.concurrent.Executors;
9. import java.util.concurrent.Future;
11. public class RunnableAndCallable2Future {
13. public static void main(String[] args) {
15. // 創建一個執行任務的服務
16. ExecutorService executor = Executors.newFixedThreadPool(3);
17. try {
18. //1.Runnable通過Future返回結果為空
19. //創建一個Runnable，來調度，等待任務執行完畢，取得返回結果
20. Future<?> runnable1 = executor.submit(new Runnable() {
21. @Override
22. public void run() {
23. System.out.println("runnable1 running.");
24. }
25. });
26. System.out.println("Runnable1:" + runnable1.get());
28. // 2.Callable通過Future能返回結果
29. //提交並執行任務，任務啟動時返回了一個 Future對象，
30. // 如果想得到任務執行的結果或者是異常可對這個Future對象進行操作
31. Future<String> future1 = executor.submit(new Callable<String>() {
32. @Override
33. public String call() throws Exception {
34. // TODO Auto-generated method stub
35. return "result=task1";
36. }
37. });
38. // 獲得任務的結果，如果調用get方法，當前線程會等待任務執行完畢後才往下執行
39. System.out.println("task1: " + future1.get());
41. //3. 對Callable調用cancel可以對對該任務進行中斷
42. //提交並執行任務，任務啟動時返回了一個 Future對象，
43. // 如果想得到任務執行的結果或者是異常可對這個Future對象進行操作
44. Future<String> future2 = executor.submit(new Callable<String>() {
45. @Override
46. public String call() throws Exception {
47. try {
48. while (true) {
49. System.out.println("task2 running.");
50. Thread.sleep(50);
51. }
52. } catch (InterruptedException e) {
53. System.out.println("Interrupted task2.");
54. }
55. return "task2=false";
56. }
57. });
59. // 等待5秒後，再停止第二個任務。因為第二個任務進行的是無限循環
60. Thread.sleep(10);
61. System.out.println("task2 cancel: " + future2.cancel(true));
63. // 4.用Callable時拋出異常則Future什麽也取不到了
64. // 獲取第三個任務的輸出，因為執行第三個任務會引起異常
65. // 所以下面的語句將引起異常的拋出
66. Future<String> future3 = executor.submit(new Callable<String>() {
68. @Override
69. public String call() throws Exception {
70. throw new Exception("task3 throw exception!");
71. }
73. });
74. System.out.println("task3: " + future3.get());
75. } catch (Exception e) {
76. System.out.println(e.toString());
77. }
78. // 停止任務執行服務
79. executor.shutdownNow();
80. }
81. }

執行結果如下：

1. runnable1 running.
2. Runnable1:null
3. task1: result=task1
4. task2 running.
5. task2 cancel: true
6. Interrupted task2.
7. java.util.concurrent.ExecutionException: java.lang.Exception: Bad flag value!

FutureTask則是一個RunnableFuture<V>，即實現了Runnbale又實現了Futrue<V>這兩個接口，另外它還可以包裝Runnable和Callable<V>，所以一般來講是一個符合體了，它可以通過Thread包裝來直接執行，也可以提交給ExecuteService來執行，並且還可以通過v get()返回執行結果，在線程體沒有執行完成的時候，主線程一直阻塞等待，執行完則直接返回結果。

1. public class FutureTaskTest {
3. /**
4. * @param args
5. */
6. public static void main(String[] args) {
7. Callable<String> task = new Callable<String>() {
8. public String call() {
9. System.out.println("Sleep start.");
10. try {
11. Thread.sleep(1000 * 10);
12. } catch (InterruptedException e) {
13. // TODO Auto-generated catch block
14. e.printStackTrace();
15. }
16. System.out.println("Sleep end.");
17. return "time=" + System.currentTimeMillis();
18. }
19. };
21. //直接使用Thread的方式執行
22. FutureTask<String> ft = new FutureTask<String>(task);
23. Thread t = new Thread(ft);
24. t.start();
25. try {
26. System.out.println("waiting execute result");
27. System.out.println("result = " + ft.get());
28. } catch (InterruptedException e) {
29. // TODO Auto-generated catch block
30. e.printStackTrace();
31. } catch (ExecutionException e) {
32. // TODO Auto-generated catch block
33. e.printStackTrace();
34. }
36. //使用Executors來執行
37. System.out.println("=========");
38. FutureTask<String> ft2 = new FutureTask<String>(task);
39. Executors.newSingleThreadExecutor().submit(ft2);
40. try {
41. System.out.println("waiting execute result");
42. System.out.println("result = " + ft2.get());
43. } catch (InterruptedException e) {
44. // TODO Auto-generated catch block
45. e.printStackTrace();
46. } catch (ExecutionException e) {
47. // TODO Auto-generated catch block
48. e.printStackTrace();
49. }
51. }
52. }

執行結果如下：

1. waiting execute result
2. Sleep start.
3. Sleep end.
4. result = time=1370844662537
5. =========
6. waiting execute result
7. Sleep start.
8. Sleep end.
9. result = time=1370844672542

Runnable、Callable、Executor、Future、FutureTask關系解讀