引子：

上图是两个系统交互的情况，现在我想将对外系统的调用做成异步实现，那么就需要考虑两个问题：

主线程可以得到异步线程的结果，在得到结果之后再进行operation-4

•主线程如何得到异步线程结果？

•主线程在得到异步线程的结果之前是否可以不等待？

可以使用Future模式来实现。

Future模式在请求发生时返回一个Future对象给发起请求的客户端，然后由一个新的线程执行真正的异步业务处理，当客户端需要异步处理的结果时，通过返回给客户端的Future对象的get()方法获取异步处理结果！

JDK的Future模式：Java.util.concurrent.future.Future接口

/** * A Future represents the result of an asynchronous * computation.  Methods are provided to check if the computation is * complete, to wait for its completion, and to retrieve the result of * the computation.  The result can only be retrieved using method * get when the computation has completed, blocking if * necessary until it is ready.  Cancellation is performed by the * cancel method.  Additional methods are provided to * determine if the task completed normally or was cancelled. Once a * computation has completed, the computation cannot be cancelled. * If you would like to use a Future for the sake * of cancellability but not provide a usable result, you can * declare types of the form {
     @code Future
     } and * return null as a result of the underlying task. * * 
 * Sample Usage (Note that the following classes are all * made-up.) 
 *  
 {
     @code * interface ArchiveSearcher { String search(String target); } * class App { *   ExecutorService executor = ... *   ArchiveSearcher searcher = ... *   void showSearch(final String target) *       throws InterruptedException { *     Future
      
        future *       = executor.submit(new Callable
       
        () { *         public String call() { *             return searcher.search(target); *         }}); *     displayOtherThings(); // do other things while searching *     try { *       displayText(future.get()); // use future *     } catch (ExecutionException ex) { cleanup(); return; } *   } * }}
       
      
 * * The {
     @link FutureTask} class is an implementation of Future that * implements Runnable, and so may be executed by an Executor. * For example, the above construction with submit could be replaced by: *  
 {
     @code *     FutureTask
      
        future = *       new FutureTask
       
        (new Callable
        
         () { *         public String call() { *           return searcher.search(target); *       }}); *     executor.execute(future);}
        
       
      
 * * 
Memory consistency effects: Actions taken by the asynchronous computation *  happen-before * actions following the corresponding {
     @code Future.get()} in another thread. * * @see FutureTask * @see Executor * @since 1.5 * @author Doug Lea * @param 
      
        The result type returned by this Future's 
       get method */public interface Future
       
         {    /**     * Attempts to cancel execution of this task.  This attempt will     * fail if the task has already completed, has already been cancelled,     * or could not be cancelled for some other reason. If successful,     * and this task has not started when 
        cancel is called,     * this task should never run.  If the task has already started,     * then the 
        mayInterruptIfRunning parameter determines     * whether the thread executing this task should be interrupted in     * an attempt to stop the task.     *     * 
       
      
After this method returns, subsequent calls to {
     @link #isDone} will     * always return true.  Subsequent calls to {
     @link #isCancelled}     * will always return true if this method returned true.     *     * @param mayInterruptIfRunning true if the thread executing this     * task should be interrupted; otherwise, in-progress tasks are allowed     * to complete     * @return false if the task could not be cancelled,     * typically because it has already completed normally;     * true otherwise     */    boolean cancel(boolean mayInterruptIfRunning);    /**     * Returns true if this task was cancelled before it completed     * normally.     *     * @return true if this task was cancelled before it completed     */    boolean isCancelled();    /**     * Returns true if this task completed.     *     * Completion may be due to normal termination, an exception, or     * cancellation -- in all of these cases, this method will return     * true.     *     * @return true 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;}

对应的任务接口是：java.util.concurrent.Callable

/** * A task that returns a result and may throw an exception. * Implementors define a single method with no arguments called * call. * * 
The Callable interface is similar to {
     @link * java.lang.Runnable}, in that both are designed for classes whose * instances are potentially executed by another thread.  A * Runnable, however, does not return a result and cannot * throw a checked exception. * * 
 The {
     @link Executors} class contains utility methods to * convert from other common forms to Callable classes. * * @see Executor * @since 1.5 * @author Doug Lea * @param 
      
        the result type of method 
       call */public interface Callable
       
         {    /**     * 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;}
       
      

把javaDoc上的代码摘抄出来看下~

public interface ArchiveSearcher {    String search(String target);}

public class App {    ExecutorService executor = ;    ArchiveSearcher searcher =    void showSearch(final String target)            throws InterruptedException {        Future
     
       future = executor.submit(new Callable
      
       () {            public String call() {                return searcher.search(target);            }        });        displayOtherThings(); // do other things while searching        try {            displayText(future.get()); // use future        } catch (ExecutionException ex) {            cleanup();            return;        }    }}
      
     

简单实用介绍：

/** * 异步任务 */public class AsynchronousTask implements Callable
     
       {    private String data;    public AsynchronousTask(String data) {        this.data = data;    }    public String call() throws Exception {        try {            System.out.println(Thread.currentThread().getName() + "AsynchronousTask start...");            //模拟异步任务的处理            Thread.sleep(1000);            System.out.println((Thread.currentThread().getName() + "AsynchronousTask end..."));        } catch (Exception ex) {            ex.printStackTrace();        }        //返回异步任务的处理结果        return "hello future";    }}
     

public class FutureTest {    public static void main(String[] args) throws Exception {        ExecutorService executor = Executors.newFixedThreadPool(10);        //进行异步任务处理        Future
     
       submit = executor.submit(new AsynchronousTask("futire test"));        System.out.println(Thread.currentThread().getName() + "FutureTest start");        //这里使用sleep方法表示对其他业务逻辑的处理        //与此同时异步任务也在执行，从而充分利用了等待时间        Thread.sleep(100);        System.out.println(Thread.currentThread().getName() + "FutureTest end");        //submit.get()获取异步执行结果        //如果异步任务call没有执行完成，则依然会等待        System.out.println("数据" + submit.get());    }}