public class MyFutureTaskTest {    public static void main(String[] args) {        ExecutorService executor = Executors.newCachedThreadPool();        FutureTask future = new FutureTask(new Callable() {            public String call() throws Exception{ //建议抛出异常                try {                    Thread.sleep(5* 1000);                    return "Hello Welcome!";                }                catch(Exception e) {                    throw new Exception("Callable terminated with Exception!"); // call方法可以抛出异常                }            }        });        executor.execute(future);        long t = System.currentTimeMillis();        try {

//            String result = future.get(3000, TimeUnit.MILLISECONDS); //取得结果，同时设置超时执行时间为5秒。            String result = future.get(); //取得结果，同时设置超时执行时间为5秒。            System.err.println("result is " + result + ", time is " + (System.currentTimeMillis() - t));        } catch (InterruptedException e) {            future.cancel(true);            System.err.println("Interrupte time is " + (System.currentTimeMillis() - t));        } catch (ExecutionException e) {            future.cancel(true);            System.err.println("Throw Exception time is " + (System.currentTimeMillis() - t));//        } catch (TimeoutException e) {//            future.cancel(true);//            System.err.println("Timeout time is " + (System.currentTimeMillis() - t));        } finally {            executor.shutdown();        }

    }}

运行结果如下：

 result is Hello Welcome!, time is 5000

如果设置了超时时间，则运行结果如下：

Timeout time is 3000

 可以看出设置超时时间的影响。

再如一个多个运行任务的例子：

public class MyAsyncExample implements Callable {    private int num;

    public MyAsyncExample(int aInt) {        this.num = aInt;    }

    public String call() throws Exception {        boolean resultOk = false;        if (num == 0) {            resultOk = true;        } else if (num == 1) {            while (true) { //infinite loop                System.out.println("looping....");                Thread.sleep(3000);            }        } else {            throw new Exception("Callable terminated with Exception!");         }        if (resultOk) {            return "Task done.";        } else {            return "Task failed";        }    }

    public static void main(String[] args) {        //定义几个任务        MyAsyncExample call1 = new MyAsyncExample(0);        MyAsyncExample call2 = new MyAsyncExample(1);        MyAsyncExample call3 = new MyAsyncExample(2);        //初始任务执行工具。        ExecutorService es = Executors.newFixedThreadPool(3);        //执行任务，任务启动时返回了一个Future对象，        Future future1 = es.submit(call1);        Future future2 = es.submit(call2);        Future future3 = es.submit(call3);        try {            //任务1正常执行完毕，future1.get()会返回线程的值            System.out.println(future1.get());            //任务2进行一个死循环，调用future2.cancel(true)来中止此线程。            Thread.sleep(3000);            System.out.println("Thread 2 terminated? :" + future2.cancel(true));            //任务3抛出异常，调用future3.get()时会引起异常的抛出            System.out.println(future3.get());        } catch (ExecutionException ex) {            ex.printStackTrace();        } catch (InterruptedException ex) {            ex.printStackTrace();        }    }}

 运行结果如下：

looping....Task done.java.util.concurrent.ExecutionException: java.lang.Exception: Callable terminated with Exception! at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:222)looping.... at java.util.concurrent.FutureTask.get(FutureTask.java:83)Thread 2 terminated? :true at org.jevo.future.sample.MyAsyncExample.main(MyAsyncExample.java:57) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at java.lang.reflect.Method.invoke(Method.java:597) at com.intellij.rt.execution.application.AppMain.main(AppMain.java:90)Caused by: java.lang.Exception: Callable terminated with Exception! at org.jevo.future.sample.MyAsyncExample.call(MyAsyncExample.java:30) at org.jevo.future.sample.MyAsyncExample.call(MyAsyncExample.java:13) at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303) at java.util.concurrent.FutureTask.run(FutureTask.java:138) at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908) at java.lang.Thread.run(Thread.java:662)

以上是对Future模型的例子。异步调用在Swing中应该十分广泛，当客户端调用一个'重'的服务端操作时，我们常采用这种方式。Swing中存在一个Future的实现——SwingWorker，这使我们十分方便地在客户端开发中使用异步调用，详细使用参见API文档。下面附一个不使用Future来实现取得异步调用的代码，如下：

public abstract class AsyncWorker {    private Object value;  //the running result    private boolean finished = false;

    private static class ThreadVar {        private Thread thread;

        ThreadVar(Thread t) {            thread = t;        }

        synchronized Thread get() {            return thread;        }

        synchronized void clear() {            thread = null;        }    }

    private ThreadVar threadVar;

    /**     * 返回当前线程运行结果。     */    protected synchronized Object getValue() {        return value;    }

    /**     * 设置当前线程运行结果     */    private synchronized void setValue(Object x) {        value = x;    }

    /**     * 调用都创建计算逻辑，将运算结果返回     */    public abstract Object construct();

    public void finished() {        finished = true;    }

    public boolean isFinished() {        return finished;    }

    public void interrupt() {        Thread t = threadVar.get();        if (t != null) {            t.interrupt();        }        threadVar.clear();    }

    public void stop() {        Thread t = threadVar.get();        if(t!=null) {            t.stop();        }        threadVar.clear();    }

    /**     * 返回 construct方法运行结果。     */    public Object get() {        while (true) {            Thread t = threadVar.get();            if (t == null) {                return getValue();            }            try {                t.join();            }            catch (InterruptedException e) {                Thread.currentThread().interrupt();                return null;            }        }    }

    public AsyncWorker() {        final Runnable doFinished = new Runnable() {            public void run() {                finished();            }        };

        Runnable doConstruct = new Runnable() {            public void run() {                try {                    setValue(construct());                }                finally {                    threadVar.clear();                }

                SwingUtilities.invokeLater(doFinished);            }        };

        Thread t = new Thread(doConstruct);        threadVar = new ThreadVar(t);    }

    /**     * Start the worker thread.     */    public void start() {        finished = false;        Thread t = threadVar.get();        if (t != null) {            t.start();        }    }

    public static void main(String[] args) {        AsyncWorker worker = new AsyncWorker() {            public Object construct() {                try {                    Thread.sleep(3*1000);                }                catch(Exception e){}                return "hello world";

            }

            public void finished() {                super.finished();                //取线程运行返回的结果//                Object obj = this.get();//                System.err.println("return is " + obj);            }        };

        long t = System.currentTimeMillis();        worker.start();        Object obj = worker.get(); //取得运行结果        System.err.println("return is " + obj + ", time = " + (System.currentTimeMillis() - t));

    }}

在上述代码中，调用者只需要扩展AsyncWorker类定义可计算的逻辑，并将逻辑结果返回。返回结果会保存在一变量中。当调用者调用返回结果时，如果计算还未完成，将调用Thread.join()阻塞线程，直到计算结果返回。用法上是不是与FutureTask相似？在Swing异步调用中，还需要结合等待对话框来表示计算运行进程，从而使运行界面显示更加友好。 

再看一下线程的join方法，我们知道线程可被Object.wait、Thread.join和Thread.sleep三种方法之一阻塞，当接收到一个中断异常（InterruptedException）时，可提早地终结被阻塞状态。Thread.join的使用情况却有所不同：我们对一些耗时运算，常启用一个主线程来生成并启动一些子线程，在子线程中进行耗时的运算，当主线程继续处理完其他的事务后，需要调用子线程的处理结果，这个时候就要使用join();。Joint方法将使主线程等待子线程运行结束，即join()方法后的代码，只有等到子线程运行结束后才能被执行。参考下例：

public class ChildThread extends Thread {    public ChildThread() {        super("ChildThread");    }

    public void run() {        String threadName = Thread.currentThread().getName();        System.out.println(threadName + " start.");        try {            for (int i = 0; i < 5; i++) {                System.out.println(threadName + " loop at " + i);                Thread.sleep(1000);            }            System.out.println(threadName + " end.");        } catch (Exception e) {            System.out.println("Exception from " + threadName + ".run");        }    }}

public class ParentThread extends Thread {    ChildThread t1;

    public ParentThread(ChildThread t1) {        super("ParentThread");        this.t1 = t1;    }

    public void run() {        String threadName = Thread.currentThread().getName();        System.out.println(threadName + " start.");        try {            t1.join();   //ChildThread 线程t1结束后，才能运行此行代码后的代码。            System.out.println(threadName + " end.");        } catch (Exception e) {            System.out.println("Exception from " + threadName + ".run");        }    }

    public static void main(String[] args) {        String threadName = Thread.currentThread().getName();        System.out.println(threadName + " start.");        ChildThread t1 = new ChildThread();        ParentThread t = new ParentThread(t1);        try {            t1.start();            Thread.sleep(2000);            t.start();            t.join();//此处注释后，将直接运行到结束代码. 注释此处代码，比较运行结果        } catch (Exception e) {            System.out.println("Exception from main");        }        System.out.println(threadName + " end!");    }

}

在t.join()被注释前运行结果如下：

main start.ChildThread start.ChildThread loop at 0ChildThread loop at 1ParentThread start.ChildThread loop at 2ChildThread loop at 3ChildThread loop at 4ChildThread end.ParentThread end.main end!

当t.join()被注释后运行结果如下： 

main start.ChildThread start.ChildThread loop at 0ChildThread loop at 1main end!ParentThread start.ChildThread loop at 2ChildThread loop at 3ChildThread loop at 4ChildThread end.ParentThread end.

可见ParentThread线程仍等待ChildThread线程运行结束后才运行完毕，而Main线程与ParentThread线程的运行并没有保持等待。