Callable、Future和FutureTask怎么使用

180次閱讀

共計 7814 個字符，預計需要花費 20 分鐘才能閱讀完成。

本篇內容主要講解“Callable、Future 和 FutureTask 怎么使用”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓丸趣 TV 小編來帶大家學習“Callable、Future 和 FutureTask 怎么使用”吧!

創建線程的 2 種方式，一種是直接繼承 Thread，另外一種就是實現 Runnable 接口。這 2 種方式都有一個缺陷就是：在執行完任務之后無法獲取執行結果。
自從 Java 1.5 開始，就提供了 Callable 和 Future，通過它們可以在任務執行完畢之后得到任務執行結果。
#CountDownLatch 用法
先說一下 java.lang.Runnable 吧，它是一個接口，在它里面只聲明了一個 run() 方法：

public interface Runnable { public abstract void run();
}

由于 run()方法返回值為 void 類型，所以在執行完任務之后無法返回任何結果。
Callable 位于 java.util.concurrent 包下，它也是一個接口，在它里面也只聲明了一個方法，只不過這個方法叫做 call()：

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

可以看到，這是一個泛型接口，call()函數返回的類型就是傳遞進來的 V 類型
那么怎么使用 Callable 呢？一般情況下是配合 ExecutorService 來使用的，在 ExecutorService 接口中聲明了若干個 submit 方法的重載版本

T  Future T  submit(Callable T  task);
 T  Future T  submit(Runnable task, T result);
Future ?  submit(Runnable task);

第一個 submit 方法里面的參數類型就是 Callable。
暫時只需要知道 Callable 一般是和 ExecutorService 配合來使用的，具體的使用方法講在后面講述。
一般情況下我們使用第一個 submit 方法和第三個 submit 方法，第二個 submit 方法很少使用。
#Future
Future 就是對于具體的 Runnable 或者 Callable 任務的執行結果進行取消、查詢是否完成、獲取結果。必要時可以通過 get 方法獲取執行結果，該方法會阻塞直到任務返回結果。
Future 類位于 java.util.concurrent 包下，它是一個接口：

public interface Future V  { boolean cancel(boolean mayInterruptIfRunning);
 boolean isCancelled();
 boolean isDone();
 V get() throws InterruptedException, ExecutionException;
 V get(long timeout, TimeUnit unit)
 throws InterruptedException, ExecutionException, TimeoutException;
}

在 Future 接口中聲明了 5 個方法，下面依次解釋每個方法的作用：

cancel 方法用來取消任務，如果取消任務成功則返回 true，如果取消任務失敗則返回 false。參數 mayInterruptIfRunning 表示是否允許取消正在執行卻沒有執行完畢的任務，如果設置 true，則表示可以取消正在執行過程中的任務。如果任務已經完成，則無論 mayInterruptIfRunning 為 true 還是 false，此方法肯定返回 false，即如果取消已經完成的任務會返回 false；如果任務正在執行，若 mayInterruptIfRunning 設置為 true，則返回 true，若 mayInterruptIfRunning 設置為 false，則返回 false；如果任務還沒有執行，則無論 mayInterruptIfRunning 為 true 還是 false，肯定返回 true。

isCancelled 方法表示任務是否被取消成功，如果在任務正常完成前被取消成功，則返回 true。

isDone 方法表示任務是否已經完成，若任務完成，則返回 true；

get()方法用來獲取執行結果，這個方法會產生阻塞，會一直等到任務執行完畢才返回；

get(long timeout, TimeUnit unit)用來獲取執行結果，如果在指定時間內，還沒獲取到結果，就直接返回 null。
因為 Future 只是一個接口，所以是無法直接用來創建對象使用的，因此就有了下面的 FutureTask。
#FutureTask

public class FutureTask V  implements RunnableFuture V {}
public interface RunnableFuture V  extends Runnable, Future V  { void run();
}

可以看出 RunnableFuture 繼承了 Runnable 接口和 Future 接口，而 FutureTask 實現了 RunnableFuture 接口。所以它既可以作為 Runnable 被線程執行，又可以作為 Future 得到 Callable 的返回值。
FutureTask 提供了 2 個構造器：

public FutureTask(Callable V  callable) {}
public FutureTask(Runnable runnable, V result) {}

事實上，FutureTask 是 Future 接口的一個唯一實現類。#使用示例

public class Test { public static void main(String[] args) { ExecutorService executor = Executors.newCachedThreadPool();
 Task task = new Task();
 Future Integer  result = executor.submit(task);
 executor.shutdown();
 
 // 第 2 種方式
 //ExecutorService executor = Executors.newCachedThreadPool();
 //Task task = new Task();
 //FutureTask Integer  futureTask = new FutureTask Integer (task);
 //executor.submit(futureTask);
 //executor.shutdown();
 // 第 3 種方式，注意這種方式和第 2 種方式效果是類似的，只不過一個使用的是 ExecutorService，一個使用的是 Thread
 //Task task = new Task();
 //FutureTask Integer  futureTask = new FutureTask Integer (task);
 //Thread thread = new Thread(futureTask);
 //thread.start();
 try { Thread.sleep(1000);
 } catch (InterruptedException e1) { e1.printStackTrace();
 }
 System.out.println( 主線程在執行任務 
 try { System.out.println( task 運行結果 +result.get());
 } catch (InterruptedException e) { e.printStackTrace();
 } catch (ExecutionException e) { e.printStackTrace();
 }
 System.out.println( 所有任務執行完畢 
 }
class Task implements Callable Integer {
 @Override
 public Integer call() throws Exception {
 System.out.println( 子線程在進行計算 
 Thread.sleep(3000);
 int sum = 0;
 for(int i=0;i i++)
 sum += i;
 return sum;
 }
}

運行結果：
子線程在進行計算
主線程在執行任務
task 運行結果 4950
所有任務執行完畢

Thread、Runnable、Callable，其中 Runnable 實現的是 void run()方法，Callable 實現的是 V call()方法，并且可以返回執行結果，其中 Runnable 可以提交給 Thread 來包裝下，直接啟動一個線程來執行，而 Callable 則一般都是提交給 ExecuteService 來執行。
簡單來說，Executor 就是 Runnable 和 Callable 的調度容器，Future 就是對于具體的調度任務的執行結果進行查看，最為關鍵的是 Future 可以檢查對應的任務是否已經完成，也可以阻塞在 get 方法上一直等待任務返回結果。Runnable 和 Callable 的差別就是 Runnable 是沒有結果可以返回的，就算是通過 Future 也看不到任務調度的結果的。

/** 
 *  通過簡單的測試程序來試驗 Runnable、Callable 通過 Executor 來調度的時候與 Future 的關系  
 */ 
package com.hadoop.thread; 
 
import java.util.concurrent.Callable; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Future; 
 
public class RunnableAndCallable2Future { 
 
 public static void main(String[] args) { 
 
 //  創建一個執行任務的服務  
 ExecutorService executor = Executors.newFixedThreadPool(3); 
 try { 
 //1.Runnable 通過 Future 返回結果為空  
 // 創建一個 Runnable，來調度，等待任務執行完畢，取得返回結果  
 Future ?  runnable1 = executor.submit(new Runnable() { 
 @Override 
 public void run() { 
 System.out.println( runnable1 running.  
 } 
 }); 
 System.out.println(Runnable1:  + runnable1.get()); 
 
 // 2.Callable 通過 Future 能返回結果  
 // 提交并執行任務，任務啟動時返回了一個  Future 對象， 
 //  如果想得到任務執行的結果或者是異?？蓪@個 Future 對象進行操作  
 Future String  future1 = executor.submit(new Callable String () { 
 @Override 
 public String call() throws Exception { 
 // TODO Auto-generated method stub 
 return  result=task1  
 } 
 }); 
 //  獲得任務的結果，如果調用 get 方法，當前線程會等待任務執行完畢后才往下執行  
 System.out.println(task1:   + future1.get()); 
 
 //3.  對 Callable 調用 cancel 可以對對該任務進行中斷  
 // 提交并執行任務，任務啟動時返回了一個  Future 對象， 
 //  如果想得到任務執行的結果或者是異?？蓪@個 Future 對象進行操作  
 Future String  future2 = executor.submit(new Callable String () { 
 @Override 
 public String call() throws Exception { 
 try { 
 while (true) { 
 System.out.println( task2 running.  
 Thread.sleep(50); 
 } 
 } catch (InterruptedException e) { 
 System.out.println( Interrupted task2.  
 } 
 return  task2=false  
 } 
 }); 
 
 //  等待 5 秒后，再停止第二個任務。因為第二個任務進行的是無限循環  
 Thread.sleep(10); 
 System.out.println(task2 cancel:   + future2.cancel(true)); 
 
 // 4. 用 Callable 時拋出異常則 Future 什么也取不到了  
 //  獲取第三個任務的輸出，因為執行第三個任務會引起異常  
 //  所以下面的語句將引起異常的拋出  
 Future String  future3 = executor.submit(new Callable String () { 
 
 @Override 
 public String call() throws Exception { 
 throw new Exception( task3 throw exception!  
 } 
 
 }); 
 System.out.println(task3:   + future3.get()); 
 } catch (Exception e) { 
 System.out.println(e.toString()); 
 } 
 //  停止任務執行服務  
 executor.shutdownNow(); 
 } 
}

執行結果如下：
runnable1 running.
Runnable1:null
task1: result=task1
task2 running.
task2 cancel: true
Interrupted task2.
java.util.concurrent.ExecutionException: java.lang.Exception:Bad flag value!
FutureTask 則是一個 RunnableFuture V，即實現了 Runnbale 又實現了 Futrue V 這兩個接口，另外它還可以包裝 Runnable 和 Callable V，所以一般來講是一個符合體了，它可以通過 Thread 包裝來直接執行，也可以提交給 ExecuteService 來執行，并且還可以通過 v get()返回執行結果，在線程體沒有執行完成的時候，主線程一直阻塞等待，執行完則直接返回結果.

public class FutureTaskTest { 
 
 /** 
 * @param args 
 */ 
 public static void main(String[] args) { 
 Callable String  task = new Callable String () { 
 public String call() { 
 System.out.println( Sleep start.  
 try { 
 Thread.sleep(1000 * 10); 
 } catch (InterruptedException e) { 
 // TODO Auto-generated catch block 
 e.printStackTrace(); 
 } 
 System.out.println( Sleep end.  
 return  time=  + System.currentTimeMillis(); 
 } 
 }; 
 
 // 直接使用 Thread 的方式執行  
 FutureTask String  ft = new FutureTask String (task); 
 Thread t = new Thread(ft); 
 t.start(); 
 try { 
 System.out.println( waiting execute result  
 System.out.println(result =   + ft.get()); 
 } catch (InterruptedException e) { 
 // TODO Auto-generated catch block 
 e.printStackTrace(); 
 } catch (ExecutionException e) { 
 // TODO Auto-generated catch block 
 e.printStackTrace(); 
 } 
 
 // 使用 Executors 來執行  
 System.out.println( =========  
 FutureTask String  ft2 = new FutureTask String (task); 
 Executors.newSingleThreadExecutor().submit(ft2); 
 try { 
 System.out.println( waiting execute result  
 System.out.println(result =   + ft2.get()); 
 } catch (InterruptedException e) { 
 // TODO Auto-generated catch block 
 e.printStackTrace(); 
 } catch (ExecutionException e) { 
 // TODO Auto-generated catch block 
 e.printStackTrace(); 
 } 
 
 } 
}

執行結果如下：
waiting execute result
Sleep start.
Sleep end.
result = time=1370844662537

=========

waiting execute result
Sleep start.
Sleep end.
result = time=1370844672542

到此，相信大家對“Callable、Future 和 FutureTask 怎么使用”有了更深的了解，不妨來實際操作一番吧！這里是丸趣 TV 網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！

正文完