多线程不得不聊的Future类

public interface Data { 
    public String getResult (); 
} 
1.
2.
3.

public class FutureData implements Data { 
    // 内部需要维护RealData 
    protected RealData realdata = null;           
    protected boolean isReady = false; 
    public synchronized void setRealData(RealData realdata) { 
        if (isReady) {  
            return; 
        } 
        this.realdata = realdata; 
        isReady = true; 
        //RealData已经被注入，通知getResult() 
        notifyAll();                                
    } 
    //会等待RealData构造完成 
    public synchronized String getResult() {          
        while (!isReady) { 
            try { 
                //一直等待，直到RealData被注入 
                wait();                            
            } catch (InterruptedException e) { 
            } 
        } 
        //真正需要的数据从RealData获取 
        return realdata.result;                       
    } 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

public class RealData implements Data { 
    protected final String result; 
    public RealData(String para) { 
        StringBuffer sb=new StringBuffer(); 
        //假设这里很慢很慢，构造RealData不是一个容易的事 
        result =sb.toString(); 
    } 
    public String getResult() { 
        return result; 
    } 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

public class Client { 
    //这是一个异步方法，返回的Data接口是一个Future 
    public Data request(final String queryStr) { 
        final FutureData future = new FutureData(); 
        new Thread() {                                       
            public void run() {                      
                // RealData的构建很慢，所以在单独的线程中进行 
                RealData realdata = new RealData(queryStr); 
                //setRealData()的时候会notify()等待在这个future上的对象 
                future.setRealData(realdata); 
            }                                                
        }.start(); 
        // FutureData会被立即返回，不会等待RealData被构造完 
        return future;                           
    } 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

public static void main(String[] args) { 
    Client client = new Client(); 
    //这里会立即返回，因为得到的是FutureData而不是RealData 
    Data data = client.request("name"); 
    System.out.println("请求完毕"); 
    try { 
        //这里可以用一个sleep代替了对其他业务逻辑的处理 
        //在处理这些业务逻辑的过程中，RealData被创建，从而充分利用了等待时间 
        Thread.sleep(2000); 
    } catch (InterruptedException e) { 
    } 
    //使用真实的数据，如果到这里数据还没有准备好，getResult()会等待数据准备完，再返回 
    System.out.println("数据 = " + data.getResult()); 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

//异步操作 可以用一个线程池 
  ExecutorService executor = Executors.newFixedThreadPool(1); 
  //执行FutureTask，相当于上例中的 client.request("name") 发送请求 
  //在这里开启线程进行RealData的call()执行 
  Future<String> future = executor.submit(new RealData("name")); 
  System.out.println("请求完毕，数据准备中"); 
  try { 
      //这里依然可以做额外的数据操作，这里使用sleep代替其他业务逻辑的处理 
      Thread.sleep(2000); 
  } catch (InterruptedException e) { 
  } 
  //如果此时call()方法没有执行完成，则依然会等待 
  System.out.println("数据 = " + future.get()); 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

public <T> Future<T> submit(Callable<T> task) { 
    if (task == null) throw new NullPointerException(); 
    // 根据Callable对象，创建一个RunnableFuture，这里其实就是FutureTask 
    RunnableFuture<T> ftask = newTaskFor(task); 
    //将ftask推送到线程池 
    //在新线程中执行的，就是run()方法，在下面的代码中有给出 
    execute(ftask); 
    //返回这个Future，将来通过这个Future就可以得到执行的结果 
    return ftask; 
} 
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) { 
    return new FutureTask<T>(callable); 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

public V get() throws InterruptedException, ExecutionException { 
       int s = state; 
       //如果没有完成，就等待，回到用park()方法阻塞线程 
       //同时，所有等待线程会在FutureTask的waiters字段中排队等待 
       if (s <= COMPLETING) 
           s = awaitDone(false, 0L); 
       return report(s); 
   } 
   private V report(int s) throws ExecutionException { 
       //outcome里保存的就是最终的计算结果 
       Object x = outcome; 
       if (s == NORMAL) 
           //正常完成，就返回outcome 
           return (V)x; 
       //如果没有正常完成， 比如被用户取消了，或者有异常了，就抛出异常 
       if (s >= CANCELLED) 
           throw new CancellationException(); 
       throw new ExecutionException((Throwable)x); 
   } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

public void run() { 
            CompletableFuture<T> d; Supplier<T> f; 
            if ((d = dep) != null && (f = fn) != null) { 
                dep = null; fn = null; 
                if (d.result == null) { 
                    try { 
                        //这里就是你要执行的异步方法 
                        //结果会被保存下来，放到d.result字段中 
                        d.completeValue(f.get()); 
                    } catch (Throwable ex) { 
                        d.completeThrowable(ex); 
                    } 
                } 
                //执行成功了，进行后续处理，在这个后续处理中，就会调用thenAccept()中的消费者 
                //这里就相当于Future完成后的通知 
                d.postComplete(); 
            } 
        } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

final void postComplete() { 
             //省略部分代码，重点在tryFire()里 
             //在tryFire()里，真正触发了后续的调用，也就是thenAccept()中的部分 
             f = (d = h.tryFire(NESTED)) == null ? this : d; 
         } 
     } 
 } 
1.
2.
3.
4.
5.
6.
7.