Callable接口类似于Runnable，从名字就可以看出来了，但是Runnable不会返回结果，并且无法抛出返回结果的异常，而Callable功能更强大一些，被线程执行后，可以返回值，这个返回值可以被Future拿到，也就是说，Future可以拿到异步执行任务的返回值，下面来看一个简单的例子
package com.future.test;
import java.io.FileNotFoundException;
import java.io.IOException;
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 MyTest {
// 接收在run方法中捕获的异常，然后自定义方法抛出异常
//private static Throwable exception;
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String result = "";
ExecutorService executor = Executors.newSingleThreadExecutor();
FutureTask<String> future =
new FutureTask<String>(new Callable<String>() {//使用Callable接口作为构造参数
public String call() {
//真正的任务在这里执行，这里的返回值类型为String，可以为任意类型
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
//exception = e;
//e.printStackTrace();
}
return "22222";
}});
executor.execute(future);
//在这里可以做别的任何事情
try {
result = future.get(5000,TimeUnit.MILLISECONDS); //取得结果，同时设置超时执行时间为5秒。同样可以用future.get()，不设置执行超时时间取得结果
} catch (InterruptedException e) {
//System.out.println("任务已经取消");
future.cancel(true);
} catch (ExecutionException e) {
future.cancel(true);
} catch (TimeoutException e) {
future.cancel(true);
} finally {
executor.shutdown();
}
System.out.println("result:"+result);
}
/* public void throwException() throws FileNotFoundException,IOException {
if (exception instanceof FileNotFoundException)
throw (FileNotFoundException) exception;
if (exception instanceof IOException)
throw (IOException) exception;
}*/
}
