Java回调实现异步 (转)

package CallBack;

public interface CallBack {
    /*
    *A处理结果的方法，为什么要写这个接口呢？
    *因为可能不止A需要用到B的处理过程，如果很多地方需要用到B
    * 那么传入B的方法就不可能只传A类，所以要定义一个接口，
    * 传入B的处理方法的参数就是这个接口对象
    * */
    public void solve(String result);
}

package CallBack;

public class A implements CallBack {
    private B b;

    public A(B b){
        this.b=b;
    }

    //A需要解决一个问题，所以他把问题交给B处理，B单独创建一个线程，不影响A的运行
    public void ask(final String question){
        System.out.println("A问了B一个问题");
        new Thread(()->{
            //B想要帮A处理东西，就必须知道谁让自己处理的，所以要传入a，也要知道a想处理什么，所以要传入question
            b.executeMessage(A.this,question);
        }).start();
        //A把要处理的事情交给b之后，就可以自己去玩耍了，或者去处理其他事情
        play();
    }

    public void play(){
        System.out.println("我要逛街去了");
    }

    //A拿到了B处理完成的结果，可以进行一些操作，比如把结果输出
    @Override
    public void solve(String result) {
        System.out.println("B告诉A的答案是--》"+result);
    }

}

package CallBack;

public class B {
    public void executeMessage(CallBack callBack,String question){
        System.out.println(callBack.getClass()+"问的问题--》"+question);
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String result="答案是2";
        callBack.solve(result);
    }
}

package CallBack;

public class test {
    public static void main(String[] args) {
        B b=new B();
        A a=new A(b);
        a.ask("1+1=?");
    }
}

运行结果：
A问了B一个问题
我要逛街去了
class CallBack.A问的问题--》1+1=?
B告诉A的答案是--》答案是2

Process finished with exit code 0

public class 多线程中的回调 {
    //这里简单地使用future和callable实现了线程执行完后
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newCachedThreadPool();
        Future<String> future = executor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("call");
                TimeUnit.SECONDS.sleep(1);
                return "str";
            }
        });
        //手动阻塞调用get通过call方法获得返回值。
        System.out.println(future.get());
        //需要手动关闭，不然线程池的线程会继续执行。
        executor.shutdown();

    //使用futuretask同时作为线程执行单元和数据请求单元。
    FutureTask<Integer> futureTask = new FutureTask(new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
            System.out.println("dasds");
            return new Random().nextInt();
        }
    });
    new Thread(futureTask).start();
    //阻塞获取返回值
    System.out.println(futureTask.get());
}
@Test
public void test () {
    Callable callable = new Callable() {
        @Override
        public Object call() throws Exception {
            return null;
        }
    };
    FutureTask futureTask = new FutureTask(callable);

}
}