Callable是java.util.concurrent包中一個介面，Callable 介面類似於Runnable，兩者都是為那些其例項可能被另一個執行緒執行的類設計的。但是Runnable 不會返回結果，並且無法丟擲經過檢查的異常。此介面中就聲明瞭一個方法call(),這個方法計算結果，如果無法計算結果，則丟擲一個異常。Executors 類包含一些從其他普通形式轉換成 Callable 類的實用方法。我們來看看此介面和它方法宣告的原始碼（JDK1.6）：

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 interface Future<V> {

    /**
     * Attempts to cancel execution of this task.  This attempt will
     * fail if the task has already completed, already been cancelled,
     * or could not be cancelled for some other reason. If successful,
     * and this task has not started when <tt>cancel</tt> is called,
     * this task should never run.  If the task has already started,
     * then the <tt>mayInterruptIfRunning</tt> parameter determines
     * whether the thread executing this task should be interrupted in
     * an attempt to stop the task.
     *
     * <p>After this method returns, subsequent calls to {@link #isDone} will
     * always return <tt>true</tt>.  Subsequent calls to {@link #isCancelled}
     * will always return <tt>true</tt> if this method returned <tt>true</tt>.
     *
     * @param mayInterruptIfRunning <tt>true</tt> if the thread executing this
     * task should be interrupted; otherwise, in-progress tasks are allowed
     * to complete
     * @return <tt>false</tt> if the task could not be cancelled,
     * typically because it has already completed normally;
     * <tt>true</tt> otherwise
     */
    boolean cancel(boolean mayInterruptIfRunning);

    /**
     * Returns <tt>true</tt> if this task was cancelled before it completed
     * normally.
     *
     * @return <tt>true</tt> if this task was cancelled before it completed
     */
    boolean isCancelled();

    /**
     * Returns <tt>true</tt> if this task completed.
     *
     * Completion may be due to normal termination, an exception, or
     * cancellation -- in all of these cases, this method will return
     * <tt>true</tt>.
     *
     * @return <tt>true</tt> if this task completed
     */
    boolean isDone();

    /**
     * Waits if necessary for the computation to complete, and then
     * retrieves its result.
     *
     * @return the computed result
     * @throws CancellationException if the computation was cancelled
     * @throws ExecutionException if the computation threw an
     * exception
     * @throws InterruptedException if the current thread was interrupted
     * while waiting
     */
    V get() throws InterruptedException, ExecutionException;

    /**
     * Waits if necessary for at most the given time for the computation
     * to complete, and then retrieves its result, if available.
     *
     * @param timeout the maximum time to wait
     * @param unit the time unit of the timeout argument
     * @return the computed result
     * @throws CancellationException if the computation was cancelled
     * @throws ExecutionException if the computation threw an
     * exception
     * @throws InterruptedException if the current thread was interrupted
     * while waiting
     * @throws TimeoutException if the wait timed out
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}
 

package CallableFuture;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CallableFutureTest {

    public static void main(String[] args) {

    	 // 定義3個Callable型別的任務
    	Callable task0 = new CallableTest(0);
    	Callable task1 = new CallableTest(1);
    	Callable task2 = new CallableTest(2);
        
        ExecutorService es = Executors.newFixedThreadPool(3);	// 建立一個執行任務的執行緒池
        try {
            
            Future future0 = es.submit(task0);	// 提交併執行任務1，任務啟動時返回了一個Future物件
            System.out.println("task0執行結果 ：" + future0.get());	// 獲得第一個任務的結果，如果呼叫get方法直到當前執行緒會等待任務執行完畢後才往下執行
            
            Future future1 = es.submit(task1);	// 提交併執行任務2，任務啟動時返回了一個Future物件
            String result1=null;
            try{
            	result1=(String) future1.get(6,TimeUnit.SECONDS);	// 如有必要，最多等待6秒之後，獲取其結果（如果結果可用），因為此時任務在無限迴圈肯定超時
            }catch(TimeoutException e){
            	System.out.println("future1用get獲取超時了！此時任務1的執行結果："+result1);
            }

            Future future2 = es.submit(task2);	// 提交併執行任務2，任務啟動時返回了一個Future物件
            System.out.println("任務2開始執行了.....");
            Thread.sleep(2000);		//主執行緒即當前執行緒停止2秒往下執行
            System.out.println("task1被cancel()取消任務，結果: " + future1.cancel(true));	//中斷任務1的迴圈
            System.out.println("task2執行結果：" + future2.get());
        } catch (Exception e){
            System.out.println(e.toString());
        }

       // 停止任務執行服務
        es.shutdownNow();
        System.out.println("所有任務全部結束了!");
    }
}
class CallableTest implements Callable{
	
    public int testData = 0; 

    public CallableTest(int testData){
        this.testData = testData;
    }
    
    @Override
    public String call() throws Exception{
	  	if (this.testData == 0){  
	  		return "testData = 0";
	  	} 
	    if (this.testData == 1){  
	    	try {
	    		while (true) {
	    			System.out.println("任務1執行中.....");
	                Thread.sleep(1000);
	            }
	        } catch (InterruptedException e) {
	      	    System.out.println("任務1中斷了.....");
	        }
	        return "如果被cancle，則不會接受返回值！";
	   } else {
		    Thread.sleep(10000);
		    return "任務2睡了10秒！";
	   }
   }
}

task0執行結果 ：testData = 0
任務1執行中.....
任務1執行中.....
任務1執行中.....
任務1執行中.....
任務1執行中.....
任務1執行中.....
future1用get獲取超時了！此時任務1的執行結果：null
任務2開始執行了.....
任務1執行中.....
任務1執行中.....
task1被cancel()取消任務，結果: true
任務1中斷了.....
task2執行結果：任務2睡了10秒！
所有任務全部結束了!

    最後，認真看過的網友們，大神們，如有感覺我這個程式猿有哪個地方說的不對或者不妥或者你有很好的

提議或者建議或點子方法，還望您大恩大德施捨n秒的時間留下你的寶貴文字（留言），以便你，我，還有廣大的程式猿們更快地成長與進步.......