提货单模式，其实就是拥有回调的线程模式。

    平时我们开发用这样的，是否运行完毕我们不知道。没有回到啊。

    1.  new Thread(new Runnable() {
    2.             @Override
    3.             public void run() {
    5.             }
    6.         }).start();

    面对这个不靠谱的行为，我们需要一个回调给我们。

    生活中这样的事情太多了，你被一个漂亮的老师忽悠去参加Android培训班，然后你就交钱了，她给你开了收据，说等通知开学吧。来的时候记得带上这个收据。留下一个美丽的背影给你。还给你约好开学一起吃饭，等等。

    我们用 Runnable 不好实现吧，要开班了，你还在家打游戏呢。

    所以我们就需要 Future。

    说明了这个原理也很简单。就是先给你一个假的对象，可以叫代理对象。不管新线程是否运行完毕都会给你返回这个，你可以通过这个代理对象来查询是否已经完事，如果完毕你就调用这个代理对象的获取信息方法。方便吧~~

    运用也很简单。

    1.     Callable ca1 = new Callable(){
    3.             @Override
    4.             public String call() throws Exception {
    5.                 try {
    6.                     Thread.sleep(1000);
    7.                 } catch (InterruptedException e) {
    8.                     e.printStackTrace();
    9.                 }
    10.                 return "完毕";
    11.             }
    12.         };
    13.         FutureTask<String> ft1 = new FutureTask<String>(ca1);
    14.         new Thread(ft1).start();

    当然我们自然是要自己实现一下了，不然还有啥意义呢？你说是吧。这才是真香。
    Data 接口，一真一假Data实现类。通过 Host ，先返回一个 FutureData，线程运行完毕的时候给 FutureData 赋值 真正的Data RealData。

    1. public  interface Data {
    2.      boolean isAvail() ;
    3.     String getContext();
    4. }
    1. public class Host {
    3.     public Data request(int i, String a) {
    4.         FutureData futureData = new FutureData();
    6.         new Thread(new Runnable() {
    7.             @Override
    8.             public void run() {
    9.                 try {
    10.                     Thread.sleep(2000);
    12.                 RealData realData = new RealData(a, i);
    13.                 futureData.setRealData(realData);
    14.                 } catch (InterruptedException e) {
    15.                     e.printStackTrace();
    16.                 }
    17.             }
    18.         }).start();
    19.         return futureData;
    20.     }
    21. }
    1. public class RealData implements Data {
    3.     String name;
    4.     int count;
    6.     public RealData(String name, int count) {
    7.         this.name = name;
    8.         this.count = count;
    9.     }
    11.     @Override
    12.     public boolean isAvail() {
    13.         return true;
    14.     }
    16.     @Override
    17.     public String getContext() {
    18.         return name + "--" + count;
    19.     }
    20. }
    1. public class FutureData implements Data {
    2.     boolean available;
    3.     Data data;
    5.     public boolean isAvail() {
    6.         return available;
    7.     }
    9.     @Override
    10.     public String getContext() {
    11.         if (data != null) {
    12.             return data.getContext();
    13.         }
    14.         return null;
    16.     }
    18.     public void setRealData(Data data) {
    19.         this.data = data;
    20.         available = true;
    21.     }
    22. }
    1. public class Main {
    2.     public static void main(String[] args) {
    3.         Host host = new Host();
    4.         Data data1 = host.request(10, "A");
    6.         while (!data1.isAvail()){
    7.             try {
    8.                 Thread.sleep(10);
    9.             } catch (InterruptedException e) {
    10.                 e.printStackTrace();
    11.             }
    12.         }
    13.         System.out.println(data1.getContext());
    14. }