模块间调用
在一个应用系统中，无论使用何种语言开发，必然存在模块之间的调用，调用的方式分为几种：
（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。
CyclicBarrier
接着讲多线程下的其他组件，第一个要讲的就是CyclicBarrier。CyclicBarrier从字面理解是指循环屏障，它可以协同多个线程，让多个线程在这个屏障前等待，直到所有线程都达到了这个屏障时，再一起继续执行后面的动作。看一下CyclicBarrier的使用实例：
public static class CyclicBarrierThread extends Thread { private CyclicBarrier cb; private int sleepSecond; public CyclicBarrierThread(CyclicBarrier cb, int sleepSecond) { this.cb = cb; this.sleepSecond = sleepSecond; } public void run() { try { System.out.println(this.getName() + "运行了"); Thread.sleep(sleepSecond * 1000); System.out.println(this.getName() + "准备等待了, 时间为" + System.currentTimeMillis()); cb.await(); System.out.println(this.getName() + "结束等待了, 时间为" + System.currentTimeMillis()); } catch (Exception e) { e.printStackTrace(); } } } public static void main(String[] args) { Runnable runnable = new Runnable() { public void run() { System.out.println("CyclicBarrier的所有线程await()结束了，我运行了, 时间为" + System.currentTimeMillis()); } }; CyclicBarrier cb = new CyclicBarrier(3, runnable); CyclicBarrierThread cbt0 = new CyclicBarrierThread(cb, 3); CyclicBarrierThread cbt1 = new CyclicBarrierThread(cb, 6); CyclicBarrierThread cbt2 = new CyclicBarrierThread(cb, 9); cbt0.start(); cbt1.start(); cbt2.start(); }
看一下运行结果：
Thread-0运行了 Thread-2运行了 Thread-1运行了 Thread-0准备等待了, 时间为1444650316313 Thread-1准备等待了, 时间为1444650319313 Thread-2准备等待了, 时间为1444650322313 CyclicBarrier的所有线程await()结束了，我运行了, 时间为1444650322313 Thread-2结束等待了, 时间为1444650322313 Thread-0结束等待了, 时间为1444650322313 Thread-1结束等待了, 时间为1444650322313
从运行结果看，由于是同一个CyclicBarrier，Thread-0先运行到了await()的地方，等着；Thread-2接着运行到了await()的地方，还等着；Thread-1最后运行到了await()的地方，所有的线程都运行到了await()的地方，所以三个线程以及指定的Runnable"同时"运行后面的代码，可以看到，await()之后，四个线程运行的时间一模一样，都是1444650322313。
从使用来看，可能有人觉得CyclicBarrier和CountDownLatch有点像，都是多个线程等待相互完成之后，再执行后面的代码。实际上，CountDownLatch和CyclicBarrier都是用于多个线程间的协调的，它们二者的几个差别是：
1、CountDownLatch是在多个线程都进行了latch.countDown()后才会触发事件，唤醒await()在latch上的线程，而执行countDown()的线程，执行完countDown()后会继续自己线程的工作；CyclicBarrier是一个栅栏，用于同步所有调用await()方法的线程，并且等所有线程都到了await()方法时，这些线程才一起返回继续各自的工作
2、另外CountDownLatch和CyclicBarrier的一个差别是，CountDownLatch不能循环使用，计数器减为0就减为0了，不能被重置，CyclicBarrier可以循环使用
3、CountDownLatch可以唤起多条线程的任务，CyclicBarrier只能唤起一条线程的任务
注意，因为使用CyclicBarrier的线程都会阻塞在await方法上，所以在线程池中使用CyclicBarrier时要特别小心，如果线程池的线程过少，那么就会发生死锁了
Callable、Future和FutureTask
Callable
Callable和rRunnable差不多，两者都是为那些其实例可能被另一个线程执行的类而设计的，最主要的差别在于Runnable不会返回线程运算结果，Callable可以（假如线程需要返回运行结果）
Future
Future是一个接口表示异步计算的结果，它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。Future提供了get()、cancel()、isCancel()、isDone()四种方法，表示Future有三种功能：
1、判断任务是否完成
2、中断任务
3、获取任务执行结果
FutureTask
FutureTask是Future的实现类，它提供了对Future的基本实现。可使用FutureTask包装Callable或Runnable对象，因为FutureTask实现了Runnable，所以也可以将FutureTask提交给Executor。
使用方法
Callable、Future、FutureTask一般都是和线程池配合使用的，因为线程池ThreadPoolExecutor的父类AbstractExecutorService提供了三种submit方法：
1、public Future<?> subit(Runnable task){...}
2、public <T> Future<T> submit<Runnable task, T result>{...}
3、public <T> Future<T> submit<Callable<T> task>{...}
第2个用得不多，第1个和第3个比较有用
Callable+Future使用示例
public static class CallableThread implements Callable<String> { public String call() throws Exception { System.out.println("进入CallableThread的call()方法, 开始睡觉, 睡觉时间为" + System.currentTimeMillis()); Thread.sleep(10000); return "123"; } } public static void main(String[] args) throws Exception { ExecutorService es = Executors.newCachedThreadPool(); CallableThread ct = new CallableThread(); Future<String> f = es.submit(ct); es.shutdown(); Thread.sleep(5000); System.out.println("主线程等待5秒, 当前时间为" + System.currentTimeMillis()); String str = f.get(); System.out.println("Future已拿到数据, str = " + str + ", 当前时间为" + System.currentTimeMillis()); }
运行结果为：
进入CallableThread的call()方法, 开始睡觉, 睡觉时间为1444654421368 主线程等待5秒, 当前时间为1444654426369 Future已拿到数据, str = 123, 当前时间为1444654431369
看到任意一个利用Callable接口submit上去的任务，只要有一个Future接受它，Future便可以在程序任何地点尝试去获取这条线程返回出去的数据，时间可以比对一下，正好10000ms，即10s
Callable+FutureTask使用示例
有兴趣的可以看下源码，其实使用Callable+Future的方式，es.submit(ct)方法返回的Future，底层实现new出来的是一个FutureTask。那么，我们看一下Callable+FutureTask的方式：
public static class CallableThread implements Callable<String> { public String call() throws Exception { System.out.println("进入CallableThread的call()方法, 开始睡觉, 睡觉时间为" + System.currentTimeMillis()); Thread.sleep(10000); return "123"; } } public static void main(String[] args) throws Exception { ExecutorService es = Executors.newCachedThreadPool(); CallableThread ct = new CallableThread(); FutureTask<String> f = new FutureTask<String>(ct); es.submit(f); es.shutdown(); Thread.sleep(5000); System.out.println("主线程等待5秒, 当前时间为" + System.currentTimeMillis()); String str = f.get(); System.out.println("Future已拿到数据, str = " + str + ", 当前时间为" + System.currentTimeMillis()); }
看下运行结果：
进入CallableThread的call()方法, 开始睡觉, 睡觉时间为1444655049199 主线程等待5秒, 当前时间为1444655054200 Future已拿到数据, str = 123, 当前时间为1444655059200
和上面的写法运行结果一样，就不解释了
使用Callable、Future和FutureTask的好处
上面演示了两个例子，其实反映的是现实中一种情况，把上面的例子稍微扩展一下就是：
有一个method()方法，方法中执行方法A返回一个数据要10秒钟，A方法后面的代码一共要执行20秒钟，但是这20秒的代码中有10秒的方法并不依赖方法A的执行结果，有10秒钟的代码依赖方法A的执行结果。此时若采用同步的方式，那么势必要先等待10秒钟，等待方法A执行完毕，返回数据，再执行后面20秒的代码。
不得不说这是一种低效率的做法。有了Callable、Future和FutureTask，那么：
1、先把A方法的内容放到Callable实现类的call()方法中
2、method()方法中，Callable实现类传入Executor的submit方法中
3、执行后面方法中10秒不依赖方法A运行结果的代码
4、获取方法A的运行结果，执行后面方法中10秒依赖方法A运行结果的代码
这样代码执行效率一下子就提高了，程序不必卡在A方法处。
当然，也可以不用Callable，采用实现Runnable的方式，run()方法执行完了想个办法给method()方法中的某个变量V赋个值就好了。但是我上一篇文章开头就说了，之所以要用多线程组件，就是因为JDK帮我们很好地实现好了代码细节，让开发者更多可以关注业务层的逻辑。如果使用Runnable的方式，那么我们自己就要考虑很多细节，比如Runnable实现类的run()方法执行完毕给V赋值是否线程安全、10秒后如果A方法没有执行完导致V还没有值怎么办，何况JDK还给用户提供了取消任务、判断任务是否存在等方法。既然JDK已经帮我们考虑并实现这些细节了，在没有有说服力的理由的情况下，我们为什么还要自己写run()方法的实现呢？
（3）回调
最后是回调，回调的思想是：
- 类A的a()方法调用类B的b()方法
- 类B的b()方法执行完毕主动调用类A的callback()方法
这样一种调用方式组成了上图，也就是一种双向的调用方式。
代码示例
接下来看一下回调的代码示例，代码模拟的是这样一种场景：老师问学生问题，学生思考完毕回答老师。
首先定义一个回调接口，只有一个方法tellAnswer(int answer)，即学生思考完毕告诉老师答案：
1 /** 2 * 回调接口，原文出处http://www.cnblogs.com/xrq730/p/6424471.html 3 */ 4 public interface Callback { 5 6 public void tellAnswer(int answer); 7 8 }
定义一个老师对象，实现Callback接口：
1 /** 2 * 老师对象，原文出处http://www.cnblogs.com/xrq730/p/6424471.html 3 */ 4 public class Teacher implements Callback { 5 6 private Student student; 7 8 public Teacher(Student student) { 9 this.student = student; 10 } 11 12 public void askQuestion() { 13 student.resolveQuestion(this); 14 } 15 16 @Override 17 public void tellAnswer(int answer) { 18 System.out.println("知道了，你的答案是" + answer); 19 } 20 21 }
老师对象有两个public方法：
（1）回调接口tellAnswer(int answer)，即学生回答完毕问题之后，老师要做的事情
（2）问问题方法askQuestion()，即向学生问问题
接着定义一个学生接口，学生当然是解决问题，但是接收一个Callback参数，这样学生就知道解决完毕问题向谁报告：
1 /** 2 * 学生接口，原文出处http://www.cnblogs.com/xrq730/p/6424471.html 3 */ 4 public interface Student { 5 6 public void resolveQuestion(Callback callback); 7 8 }
最后定义一个具体的学生叫Ricky：
1 /** 2 * 一个名叫Ricky的同学解决老师提出的问题，原文出处http://www.cnblogs.com/xrq730/p/6424471.html 3 */ 4 public class Ricky implements Student { 5 6 @Override 7 public void resolveQuestion(Callback callback) { 8 // 模拟解决问题 9 try { 10 Thread.sleep(3000); 11 } catch (InterruptedException e) { 12 13 } 14 15 // 回调，告诉老师作业写了多久 16 callback.tellAnswer(3); 17 } 18 19 }
在解决完毕问题之后，第16行向老师报告答案。
写一个测试类，比较简单：
1 /** 2 * 回调测试，原文出处http://www.cnblogs.com/xrq730/p/6424471.html 3 */ 4 public class CallbackTest { 5 6 @Test 7 public void testCallback() { 8 Student student = new Ricky(); 9 Teacher teacher = new Teacher(student); 10 11 teacher.askQuestion(); 12 13 } 14 15 }
代码运行结果就一行：
知道了，你的答案是3
简单总结、分析一下这个例子就是：
（1）老师调用学生接口的方法resolveQuestion，向学生提问
（2）学生解决完毕问题之后调用老师的回调方法tellAnswer
这样一套流程，构成了一种双向调用的关系。
代码分析
分析一下上面的代码，上面的代码我这里做了两层的抽象：
（1）将老师进行抽象
- 将老师进行抽象之后，对于学生来说，就不需要关心到底是哪位老师询问我问题，只要我根据询问的问题，得出答案，然后告诉提问的老师就可以了，即使老师换了一茬又一茬，对我学生而言都是没有任何影响的
（2）将学生进行抽象
- 将学生进行抽象之后，对于老师这边来说就非常灵活，因为老师未必对一个学生进行提问，可能同时对Ricky、Jack、Lucy三个学生进行提问，这样就可以将成员变量Student改为List<Student>，这样在提问的时候遍历Student列表进行提问，然后得到每个学生的回答即可
这个例子是一个典型的体现接口作用的例子，之所以这么说是因为我想到有些朋友可能不太明白接口的好处，不太明白接口好处的朋友可以重点看一下这个例子，多多理解。
总结起来，回调的核心就是回调方将本身即this传递给调用方，这样调用方就可以在调用完毕之后告诉回调方它想要知道的信息。回调是一种思想、是一种机制，至于具体如何实现，如何通过代码将回调实现得优雅、实现得可扩展性比较高，一看开发者的个人水平，二看开发者对业务的理解程度。
同步回调与异步回调
上面的例子，可能有人会提出这样的疑问：
这个例子需要用什么回调啊，使用同步调用的方式，学生对象回答完毕问题之后直接把回答的答案返回给老师对象不就好了？
这个问题的提出没有任何问题，可以从两个角度去理解这个问题。
首先，老师不仅仅想要得到学生的答案怎么办？可能这个老师是个更喜欢听学生解题思路的老师，在得到学生的答案之前，老师更想先知道学生姓名和学生的解题思路，当然有些人可以说，那我可以定义一个对象，里面加上学生的姓名和解题思路不就好了。这个说法在我看来有两个问题：
（1）如果老师想要的数据越来越多，那么返回的对象得越来越大，而使用回调则可以进行数据分离，将一批数据放在回调方法中进行处理，至于哪些数据依具体业务而定，如果需要增加返回参数，直接在回调方法中增加即可
（2）无法解决老师希望得到学生姓名、学生解题思路先于学生回答的答案的问题
因此我认为简单的返回某个结果确实没有必要使用回调而可以直接使用同步调用，但是如果有多种数据需要处理且数据有主次之分，使用回调会是一种更加合适的选择，优先处理的数据放在回调方法中先处理掉。
另外一个理解的角度则更加重要，就是标题说的同步回调和异步回调了。例子是一个同步回调的例子，意思是老师向Ricky问问题，Ricky给出答案，老师问下一个同学，得到答案之后继续问下一个同学，这是一种正常的场景，但是如果我把场景改一下：
老师并不想One-By-One这样提问，而是同时向Ricky、Mike、Lucy、Bruce、Kate五位同学提问，让同学们自己思考，哪位同学思考好了就直接告诉老师答案即可。
这种场景相当于是说，同学思考完毕完毕问题要有一个办法告诉老师，有两个解决方案：
（1）使用Future+Callable的方式，等待异步线程执行结果，这相当于就是同步调用的一种变种，因为其本质还是方法返回一个结果，即学生的回答
（2）使用异步回调，同学回答完毕问题，调用回调接口方法告诉老师答案即可。由于老师对象被抽象成了Callback接口，因此这种做法的扩展性非常好，就像之前说的，即使老师换了换了一茬又一茬，对于同学来说，只关心的是调用Callback接口回传必要的信息即可
301
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
