模块间的调用
本部分摘自https://www.cnblogs.com/xrq730/p/6424471.html
在一个应用系统中，无论使用何种语言开发，必然存在模块之间的调用，调用的方式分为几种：
（1）同步调用
同步调用是最基本并且最简单的一种调用方式，类A的方法a()调用类B的方法b()，一直等待b()方法执行完毕，a()方法继续往下走。这种调用方式适用于方法b()执行时间不长的情况，因为b()方法执行时间一长或者直接阻塞的话，a()方法的余下代码是无法执行下去的，这样会造成整个流程的阻塞。
（2）异步调用
异步调用是为了解决同步调用可能出现阻塞，导致整个流程卡住而产生的一种调用方式。类A的方法方法a()通过新起线程的方式调用类B的方法b()，代码接着直接往下执行，这样无论方法b()执行时间多久，都不会阻塞住方法a()的执行。
但是这种方式，由于方法a()不等待方法b()的执行完成，在方法a()需要方法b()执行结果的情况下（视具体业务而定，有些业务比如启异步线程发个微信通知、刷新一个缓存这种就没必要），必须通过一定的方式对方法b()的执行结果进行监听。
在Java中，可以使用Future+Callable的方式做到这一点，具体做法可以参见我的这篇文章Java多线程21：多线程下其他组件之CyclicBarrier、Callable、Future和FutureTask。
（3）回调
1、什么是回调？一般来说，模块之间都存在一定的调用关系，从调用方式上看，可以分为三类同步调用、异步调用和回调。同步调用是一种阻塞式调用，即在函数A的函数体里通过书写函数B的函数名来调用之，使内存中对应函数B的代码得以执行。异步调用是一种类似消息或事件的机制解决了同步阻塞的问题，例如 A通知 B后，他们各走各的路，互不影响，不用像同步调用那样， A通知 B后，非得等到 B走完后， A才继续走 。回调是一种双向的调用模式，也就是说，被调用的接口被调用时也会调用对方的接口，例如A要调用B，B在执行完又要调用A。
2、回调的用途回调一般用于层间协作，上层将本层函数安装在下层，这个函数就是回调，而下层在一定条件下触发回调。例如作为一个驱动，是一个底层，他在收到一个数据时，除了完成本层的处理工作外，还将进行回调，将这个数据交给上层应用层来做进一步处理，这在分层的数据通信中很普遍。
多线程中的“回调”
Java多线程中可以通过callable和future或futuretask结合来获取线程执行后的返回值。实现方法是通过get方法来调用callable的call方法获取返回值。
其实这种方法本质上不是回调，回调要求的是任务完成以后被调用者主动回调调用者的接口。而这里是调用者主动使用get方法阻塞获取返回值。
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); } }复制代码
Java回调机制实战
曾经自己偶尔听说过回调机制，隐隐约约能够懂一些意思，但是当让自己写一个简单的示例程序时，自己就傻眼了。随着工作经验的增加，自己经常听到这儿使用了回调，那儿使用了回调，自己是时候好好研究一下Java回调机制了。网上关于Java回调的文章一抓一大把，但是看完总是云里雾里，不知所云，特别是看到抓取别人的代码走两步时，总是现眼。于是自己决定写一篇关于Java机制的文章，以方便大家和自己更深入的学习Java回调机制。
首先，什么是回调函数，引用百度百科的解释：回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应[2].
不好意思，上述解释我看了好几遍，也没理解其中深刻奥秘，相信一些读者你也一样。光说不练假把式，咱们还是以实战理解脉络。
实例一 ： 同步调用
本文以底层服务BottomService和上层服务UpperService为示例，利用上层服务调用底层服务，整体执行过程如下：
第一步: 执行UpperService.callBottomService();
第二步: 执行BottomService.bottom();
第三步:执行UpperService.upperTaskAfterCallBottomService()
1.1 同步调用代码
同步调用时序图：
[外链图片转存失败(img-dapFATDy-1569148364574)(https://upload-images.jianshu.io/upload_images/3796264-6a5b5b898aa3930e.png?imageMogr2/auto-orient/strip|imageView2/2/w/1031/format/webp)]
同步调用时序图
1.1.1 底层服务类:BottomService.java
package synchronization.demo; /** * Created by lance on 2017/1/19. */ public class BottomService { public String bottom(String param) { try { // 模拟底层处理耗时，上层服务需要等待 Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } return param +" BottomService.bottom() execute -->"; } } 复制代码
1.1.2 上层服务接口: UpperService.java
package synchronization.demo; /** * Created by lance on 2017/1/19. */ public interface UpperService { public void upperTaskAfterCallBottomService(String upperParam); public String callBottomService(final String param); } 复制代码
1.1.3 上层服务接口实现类:UpperServiceImpl.java
package synchronization.demo; /** * Created by lance on 2017/1/19. */ public class UpperServiceImpl implements UpperService { private BottomService bottomService; @Override public void upperTaskAfterCallBottomService(String upperParam) { System.out.println(upperParam + " upperTaskAfterCallBottomService() execute."); } public UpperServiceImpl(BottomService bottomService) { this.bottomService = bottomService; } @Override public String callBottomService(final String param) { return bottomService.bottom(param + " callBottomService.bottom() execute --> "); } } 复制代码
1.1.4 Test测试类:Test.java
package synchronization.demo; import java.util.Date; /** * Created by lance on 2017/1/19. */ public class Test { public static void main(String[] args) { BottomService bottomService = new BottomService(); UpperService upperService = new UpperServiceImpl(bottomService); System.out.println("=============== callBottomService start ==================:" + new Date()); String result = upperService.callBottomService("callBottomService start --> "); //upperTaskAfterCallBottomService执行必须等待callBottomService()调用BottomService.bottom()方法返回后才能够执行 upperService.upperTaskAfterCallBottomService(result); System.out.println("=============== callBottomService end ====================:" + new Date()); } } 复制代码
1.1.5 输出结果:
=============== callBottomService start ==================:Thu Jan 19 14:59:58 CST 2017 callBottomService start --> callBottomService.bottom() execute --> BottomService.bottom() execute --> upperTaskAfterCallBottomService() execute. =============== callBottomService end ====================:Thu Jan 19 15:00:01 CST 2017 复制代码
注意输出结果：
是同步方式，Test调用callBottomService()等待执行结束，然后再执行下一步，即执行结束。callBottomService开始执行时间为Thu Jan 19 14:59:58 CST 2017，执行结束时间为Thu Jan 19 15:00:01 CST 2017，耗时3秒钟，与模拟的耗时时间一致，即3000毫秒。
Java基础12-深入理解Java中回调机制（二 ）：https://developer.aliyun.com/article/1535684
