Java--线程异步回调模型

在实际的应用场景中，将一个任务让一个线程异步去处理，处理完成后回调。
数据接口：

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();
    }

    @Override
    public synchronized String getResult() {
        while (!isReady) {
            try {
                //结果还没构造完成，获取方法陷入等待中
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return realData.result;
    }
}

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(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        result = sb.toString();
    }

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

客户端：

public class Client {

    public Data request(final String queryStr) {
        final FutureData futureData = new FutureData();
        //启动一个线程异步的去处理
        new Thread() {
            @Override
            public void run() {
                RealData realData = new RealData(queryStr);
                futureData.setRealData(realData);
            }
        }.start();
        return futureData;
    }
}

启动类：

public class TestMain {

    public static void main(String[] args) {
        Client client = new Client();
        Data data = client.request("123-");
        System.out.println("请求完毕");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("异步返回结果=" + data.getResult());
    }
}

JDK内置的回调
启动方法：

public class TestMain {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask<String> future=new FutureTask<String>(new RealData("a"));
        ExecutorService executorService=Executors.newFixedThreadPool(1);
        executorService.submit(future);
        System.out.println("发起请求完毕");

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("数据="+future.get());
    }
}

线程：

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);
            Thread.sleep(100);
        }
        return sb.toString();
    }
}