瘋狂Java學習筆記（66）-----------Callable、Future和FutureTask

標籤：

在前面的文章中我們講述了建立線程的2種方式，一種是直接繼承Thread，另外一種就是實現Runnable介面。

　　這2種方式都有一個缺陷就是：在執行完任務之後無法擷取執行結果。

　　如果需要擷取執行結果，就必須通過共用變數或者使用線程通訊的方式來達到效果，這樣使用起來就比較麻煩。

　　而自從Java 1.5開始，就提供了Callable和Future，通過它們可以在任務執行完畢之後得到任務執行結果。

　　今天我們就來討論一下Callable、Future和FutureTask三個類的使用方法。以下是本文的目錄大綱：

　　一.Callable與Runnable

　　二.Future

　　三.FutureTask

　　四.使用樣本

　

一.Callable與Runnable

Callable和Runnable有幾點不同：
 （1）Callable規定的方法是call()，而Runnable規定的方法是run().
 （2）Callable的任務執行後可返回值，而Runnable的任務是不能返回值的。
 （3）call()方法可拋出異常，而run()方法是不能拋出異常的。
 （4）運行Callable任務可拿到一個Future對象，

　　先說一下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;}

 

執行個體：

 

public class CallableTest {// 建立一個計算任務，返回累加結果，構造器的參數是上界static class SumCaller implements Callable<Long> {private Integer count;public SumCaller(Integer count) {this.count = count;}public Long call() throws Exception {long sum = 0;for (int i = 0; i < count; i++) {sum += i;}return sum;}}private static Integer COUNT = 1000000000;public static void main(String[] args) throws InterruptedException,ExecutionException {SumCaller caller = new SumCaller(COUNT);FutureTask<Long> task = new FutureTask<Long>(caller);Thread thread = new Thread(task);thread.start();long sum = task.get();System.out.println("sum from 1 to " + COUNT + " result = " + sum);}}

 　　可以看到，這是一個泛型介面，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 表示非同步計算的結果。它提供了檢查計算是否完成的方法，以等待計算的完成，並檢索計算的結果。
通過Future對象可瞭解任務執行情況，可取消任務的執行，還可擷取任務執行的結果。

　　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;}

 

FutureTask是為了彌補Thread的不足而設計的，它可以讓程式員準確地知道線程什麼時候執行完成並獲得到線程執行完成後返回的結果（如果有需要）。

 

FutureTask是一種可以取消的非同步計算任務。它的計算是通過Callable實現的，它等價於可以攜帶結果的Runnable，並且有三個狀態：等待、運行和完成。完成包括所有計算以任意的方式結束，包括正常結束、取消和異常。

 

 　　在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提供了三種功能：

　　1）判斷任務是否完成；

　　2）能夠中斷任務；

　　3）能夠擷取任務執行結果。

　　因為Future只是一個介面，所以是無法直接用來建立對象使用的，因此就有了下面的FutureTask。

三.FutureTask

　　我們先來看一下FutureTask的實現：

public class FutureTask<V> implements RunnableFuture<V>

 　　FutureTask類實現了RunnableFuture介面，我們看一下RunnableFuture介面的實現：

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介面的一個唯一實作類別。

 

四.使用樣本

　　1.使用Callable+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();                 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<100;i++)            sum += i;        return sum;    }}

 　　執行結果：

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

　　

2.使用Callable+FutureTask擷取執行結果

public class Test {    public static void main(String[] args) {        //第一種方式        ExecutorService executor = Executors.newCachedThreadPool();        Task task = new Task();        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);        executor.submit(futureTask);        executor.shutdown();                 //第二種方式，注意這種方式和第一種方式效果是類似的，只不過一個使用的是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運行結果"+futureTask.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<100;i++)            sum += i;        return sum;    }}

  

 　　如果為了可取消性而使用 Future 但又不提供可用的結果，則可以聲明 Future<?> 形式類型、並返回 null 作為底層任務的結果。

 

package test;import java.util.Random;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;/** * * @author Administrator * */@SuppressWarnings("all")public class FutureTaskDemo {public static void main(String[] args) {// 初始化一個Callable對象和FutureTask對象Callable pAccount = new PrivateAccount();FutureTask futureTask = new FutureTask(pAccount);// 使用futureTask建立一個線程Thread pAccountThread = new Thread(futureTask);System.out.println("futureTask線程現在開始啟動，啟動時間為：" + System.nanoTime());pAccountThread.start();System.out.println("主線程開始執行其他任務");// 從其他賬戶擷取總金額int totalMoney = new Random().nextInt(100000);System.out.println("現在你在其他賬戶中的總金額為" + totalMoney);System.out.println("等待私人賬戶總金額統計完畢...");// 測試背景計算線程是否完成，如果未完成則等待while (!futureTask.isDone()) {try {Thread.sleep(500);System.out.println("私人賬戶計算未完成繼續等待...");} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("futureTask線程計算完畢，此時時間為" + System.nanoTime());Integer privateAccountMoney = null;try {privateAccountMoney = (Integer) futureTask.get();} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}System.out.println("您現在的總金額為：" + totalMoney + privateAccountMoney.intValue());}}@SuppressWarnings("all")class PrivateAccount implements Callable {Integer totalMoney;@Overridepublic Object call() throws Exception {Thread.sleep(5000);totalMoney = new Integer(new Random().nextInt(10000));System.out.println("您當前有" + totalMoney + "在您的私人賬戶中");return totalMoney;}}

 

 

總結：

 FutureTask多用於耗時的計算，主線程可以在完成自己的任務後，再去擷取結果。

 

單獨使用Runnable時：

        無法獲得返回值

 

單獨使用Callable時：

        無法在新線程中(new Thread(Runnable r))使用，只能使用ExecutorService

       Thread類只支援Runnable

 

FutureTask：

         實現了Runnable和Future，所以兼顧兩者優點

         既可以使用ExecutorService，也可以使用Thread

 

 

 

　若有不正之處請多多諒解，並歡迎批評指正。

　　本文借鑒於：

　　http://www.cnblogs.com/dolphin0520/p/3949310.html

　　

 

瘋狂Java學習筆記（66）-----------Callable、Future和FutureTask