Callable介面和Future介面介紹

        在Java中，如果需要設定程式碼執行的最長時間，即超時，可以用Java執行緒池ExecutorService類配合Future介面來實現。 Future介面是Java標準API的一部分，在java.util.concurrent包中。Future介面是Java執行緒Future模式的實現，可以來進行非同步計算。

        Future模式可以這樣來描述：我有一個任務，提交給了Future，Future替我完成這個任務。期間我自己可以去做任何想做的事情。一段時間之後，我就便可以從Future那兒取出結果。就相當於下了一張訂貨單，一段時間後可以拿著提訂單來提貨，這期間可以幹別的任何事情。其中Future 介面就是訂貨單，真正處理訂單的是Executor類，它根據Future介面的要求來生產產品。

        Future介面提供方法來檢測任務是否被執行完，等待任務執行完獲得結果，也可以設定任務執行的超時時間。這個設定超時的方法就是實現Java程式執行超時的關鍵。

        Future介面是一個泛型介面，嚴格的格式應該是Future<V>，其中V代表了Future執行的任務返回值的型別。 Future介面的方法介紹如下：

• boolean cancel (boolean mayInterruptIfRunning) 取消任務的執行。引數指定是否立即中斷任務執行，或者等等任務結束
• boolean isCancelled () 任務是否已經取消，任務正常完成前將其取消，則返回 true
• boolean isDone () 任務是否已經完成。需要注意的是如果任務正常終止、異常或取消，都將返回true
• V get () throws InterruptedException, ExecutionException  等待任務執行結束，然後獲得V型別的結果。InterruptedException 執行緒被中斷異常， ExecutionException任務執行異常，如果任務被取消，還會丟擲CancellationException
• V get (long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException 同上面的get功能一樣，多了設定超時時間。引數timeout指定超時時間，uint指定時間的單位，在列舉類TimeUnit中有相關的定義。如果計算超時，將丟擲TimeoutException

         Future的實現類有java.util.concurrent.FutureTask<V>即 javax.swing.SwingWorker<T,V>。通常使用FutureTask來處理我們的任務。FutureTask類同時又實現了Runnable介面，所以可以直接提交給Executor執行。使用FutureTask實現超時執行的程式碼如下：

ExecutorService executor = Executors.newSingleThreadExecutor();  
FutureTask<String> future =  
       new FutureTask<String>(new Callable<String>() {//使用Callable介面作為構造引數  
         public String call() {  
           //真正的任務在這裡執行，這裡的返回值型別為String，可以為任意型別  
       }});  
executor.execute(future);  
//在這裡可以做別的任何事情  
try {  
    result = future.get(5000, TimeUnit.MILLISECONDS); //取得結果，同時設定超時執行時間為5秒。同樣可以用future.get()，不設定執行超時時間取得結果  
} catch (InterruptedException e) {  
    futureTask.cancel(true);  
} catch (ExecutionException e) {  
    futureTask.cancel(true);  
} catch (TimeoutException e) {  
    futureTask.cancel(true);  
} finally {  
    executor.shutdown();  
}  

package testexception;  
  
import java.util.concurrent.Callable;  
import java.util.concurrent.ExecutionException;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.FutureTask;  
import java.util.concurrent.TimeUnit;  
import java.util.concurrent.TimeoutException;  
  
  
public class FutureTaskTest{  
    public static void main(String[] args) {  
        ExecutorService executor = Executors.newSingleThreadExecutor();  
        FutureTask futureTask =  
               new FutureTask(new Callable() {//使用Callable介面作為構造引數  
                 public String call() {  
                     /*
                      * 例1：try catch在for迴圈之外，  futureTask.cancel(true);  取消後不再執行;
                      try {  
                         for (int i = 0; i < 5; i++) {  
                             Thread.sleep(1000);  
                             System.out.println("------------------------"+i);  
                        }  
                    } catch (InterruptedException e) {  
                        System.out.println("InterruptedException ");  
                        e.printStackTrace();  
                    }  */
                     //try catch在for迴圈內，  futureTask.cancel(true);  取消後繼續執行
                      try {  
                         for (int i = 0; i < 5; i++) {  
                             Thread.sleep(1000);  
                             System.out.println("------------------------"+i);  
                        }  
                    } catch (InterruptedException e) {  
                        System.out.println("InterruptedException1111111");  
                        e.printStackTrace();  
                    }  
                   //真正的任務在這裡執行，這裡的返回值型別為String，可以為任意型別  
                    return "call result";  
               }});  
        executor.execute(futureTask);  
        //在這裡可以做別的任何事情  
        try {  
            String result = futureTask.get(3000, TimeUnit.MILLISECONDS);   
            //取得結果，同時設定超時執行時間為5秒。同樣可以用future.get()，不設定執行超時時間取得結果  
            System.out.println("___________"+result+"_______________");  
        } catch (InterruptedException e) {  
            System.out.println("InterruptedException ");  
            futureTask.cancel(true);  
        } catch (ExecutionException e) {  
            System.out.println("ExecutionException ");  
            futureTask.cancel(true);  
        } catch (TimeoutException e) {  
            System.out.println("!!!!!!!!Time out!!!!!!!!!!");  
            futureTask.cancel(true);  //取消執行的執行緒
        } finally {  
            executor.shutdown();  
        }  
    }  
}