//Data.java   * 首先看这个接口Data,只有一个方法getRequest(),返回String字符串.

   public interface Data {

       String getRequest();

   }

   //RealData.java   * 然后再看RealData这个类,实现了Data接口,首先他有构造函数,可以理解为一个真实的业务逻辑，比较耗时,做这个sleep我们可以想象成在处理业务逻辑.

   public class RealData implements Data{

       private String result;

       public RealData(String queryStr){

           System.out.println("根据"+queryStr+"进行查询，这是一个很耗时的操作..");

           try {

               Thread.sleep(5000);

           } catch (InterruptedException e) {

               e.printStackTrace();

           }

           System.out.println("操作完毕，获取结果");

           result="查询结果";

       }

       @Override

       public String getRequest() {

           return result;

       }

   }

   //FutureData.java* 接着再看FutureData这个类,也实现了Data接口.先看FutureData的getRequest()方法,这个方法先死循环判断boolean,如果isReady是true,就阻塞着,不然就返回RealData真的getRequest()\\\方法(真实的结果).

   //  然后再看setRealData(),判断isReady,如果是ture,直接return,如果不是就赋值RealData,并修改isReady,然后notify()..

   public class FutureData implements Data{

       private RealData realData;

       private boolean isReady = false;

       public synchronized void setRealData(RealData realData){

           //如果已经加载完毕就直接返回

           if(isReady){

               return;

           }

           //如果没有装载，进行装载真实对象

           this.realData= realData;

           isReady = true;

           //进行通知

           notify();

       }

       @Override

       public synchronized String getRequest() {

           //如果没有装载好，程序就一直处于阻塞状态

           while(!isReady){

               try {

                   wait();

               } catch (InterruptedException e) {

                   e.printStackTrace();

               }

           }

           //装载好直接获取数据即可

           return this.realData.getRequest();

       }

   }

   //FutureClient.java * 最后看FutureClient 这个类,最简单了,返回futureData,偷偷开了线程,看到RealData realData = new RealData(request)没有?就是开始执行业务了,然后当FutureData这个类的setRealData(RealData realData)时就通知了..

   public class FutureClient {

       public Data request(final String queryStr){

           //1 我想要一个代理对象（Data接口的实现类）先返回发送请求的客户端，告诉他请求已经接收到，可以做其他事情

           final FutureData futureData = new FutureData();

           //2 启动一个新的线程，去加载真实的数据，传递给这个代理对象

           new Thread(new Runnable(){

               @Override

               public void run() {

                   //3 这个新的线程可以去慢慢加载真实对象，然后传递给代理对象

                   RealData realData = new RealData(queryStr);

                   futureData.setRealData(realData);

               }

           }).start();

           //直接返回一个假的包装类futureData

           return futureData;

       }

   }

   //主函数

   public class Main {

     public static void main(String[] args) {

         FutureClient fc = new FutureClient();

         Data data = fc.request("请求参数");

         System.out.println("请求发送成功！");

         System.out.println("做其他的事情...");

         String result = data.getRequest();

         System.out.println(result);

     }

   }

 //

   import java.util.concurrent.Callable;

   public class RealData implements Callable<String> {

     private String Data;

     public RealData(String Data) {

         this.Data = Data;

     }

     public String call() throws Exception {

         //利用sleep来表示任务处理

         Thread.sleep(2000);

         return "这是处理"+Data+"结果";

     }

   }

   //

   import java.util.concurrent.ExecutorService;

   import java.util.concurrent.Executors;

   import java.util.concurrent.FutureTask;

   public class Main {

       public static void main(String[] args) throws Exception {

           Long start = System.currentTimeMillis();

           FutureTask<String> futureTask = new FutureTask<>(new RealData("hello,world"));

           ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(1);

           newFixedThreadPool.submit(futureTask);

           // 表示正在处理其他逻辑,或者业务

           Thread.sleep(1000);

           System.out.println("最后结果-->" + futureTask.get());

           Long end = System.currentTimeMillis();

           Long useTime = end - start;

           System.out.println("程序运行了-->" + useTime + "毫秒");

       }

   }