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

}

}

CompletableFuture