加载数据太慢？无阻塞异步获取数据之Future模式

思想和应用场景

如果获取真实数据比较慢，我们可以先用假数据替代，此时用户可以继续操作界面，然后用异步的方式获取真数据，等获取到真实数据的时候，才用真实数据替代假数据。
这个在以前网络比较慢的时候，我们用Android手机看带有图片的新闻时体验特别明显，我们打开新闻后，文字很快的出现在我们面前，但是图片确显示了一张“加载中……”的假图片，这个时候，后台会开启很多新的线程，去分别获取真实的图片，当真实的图片获取后，就异步的替换“加载中……”的假“”图片

步骤

• 客户端请求数据
• 服务器接收请求，并针对加载耗时的数据（比如图片），马上返回一个假数据（加载中……）的图片
• 客户端显示假数据，用户可以自由操作其他事情（比如：阅读文字），而不是等待服务器返回数据
• 服务器开始异步获取真实数据…………，获取到真实数据后，将真实数据返回给客户端
• 客户端接收真实数据，替换假数据

角色

• Client：客户端负责显示数据
• Data：数据接口，真实数据和假数据都实现它
• FutureData：返回假数据的类，保留一个注入真实数据的方法
• RealData：获取真实数据的类

代码实现

• Data 数据接口

public interface Data {
    public String getResult();
}

• 假数据实现

public class FutureData implements Data{
    protected RealData realdata = null;
    protected boolean isReady = false;
    public synchronized void setRealData(RealData realdata){
        if (isReady){
            return;
        }
        this.realdata = realdata;
        isReady = true;
        notifyAll(); //唤醒所有 wait 线程
    }


    @Override
    public synchronized String getResult() {
        while(!isReady){
            try {
                wait(); //等待notifyAll 唤醒
            } catch (InterruptedException e){

            }
        }
        return realdata.result;
    }

    @Override
    public String toString() {
        return "已获得假数据……";
    }
}

• 真实数据获得

public class RealData implements Data {
    protected final String result;

    public RealData(String para){
        StringBuffer sb = new StringBuffer();
        for (int i = 0;i < 10;i++){
            sb.append(para);
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){

            }
        }
        result = sb.toString();
    }

    @Override
    public String getResult() {
        return result;
    }
}

• Client 客户端

public class Client {
    public Data request(final String queryStr){
        final FutureData future  = new FutureData();
        new Thread(){
            public void run(){
                RealData realData = new RealData(queryStr);
                future.setRealData(realData);
            }
        }.start();
        return future;
    }

    public static void main(String[] args) {
        Client client = new Client();
        Data data = client.request("abc  ");
        System.out.println("假数据：" + data);
        System.out.println("=========大约等待10秒=======================");
        System.out.println("真实数据：" + data.getResult());
    }

• 最后显示

假数据：已获得假数据……
=========大约等待10秒=======================
真实数据：abc  abc  abc  abc  abc  abc  abc  abc  abc  abc  

JDK内置的Future模式

这里只是想讲解Future的思想，并不深入API讲解，下面是用JDK的API替换上面代码的方法，只需要RealData 和Main 类

• RealData

public class RealData implements Callable<String> {
    private String para;
    public RealData(String para){
    	this.para=para;
    }
	@Override
	public String call() throws Exception {
    	
    	StringBuffer sb=new StringBuffer();
        for (int i = 0; i < 10; i++) {
        	sb.append(para);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
        }
        return sb.toString();
	}
}

• Main类

public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //构造FutureTask
        FutureTask<String> future = new FutureTask<String>(new RealData("abc "));
        ExecutorService executor = Executors.newFixedThreadPool(1);
        //执行FutureTask，相当于上例中的 client.request("a") 发送请求
        //在这里开启线程进行RealData的call()执行
        executor.submit(future);
        System.out.println("请求完毕，获得假数据");
        try {
            //这里依然可以做额外的数据操作，这里使用sleep代替其他业务逻辑的处理
            Thread.sleep(2000);
        } catch (InterruptedException e) {
        }
        //相当于上例中得data.getContent()，取得call()方法的返回值
        //如果此时call()方法没有执行完成，则依然会等待
        System.out.println("真实数据 ： " + future.get());
    }
}