案例：对账系统的业务是这样的，用户通过在线商城下单，会生成电子订单，保存在订单库；之后物流会生成派送单给用户发货，派送单保存在派送单库。为了防止漏派送或者重复派送，对账系统每天还会校验是否存在异常订单。对账系统的处理逻辑很简单，系统流程图如下。目前对账系统的处理逻辑是首先查询订单，然后查询派送单，之后对比订单和派送单，将差异写入差异库。
对上面的代码抽象就是这样的,就是在一个单线程里面循环查询订单、派送单，然后执行对账，最后将写入差异库。
while(存在未对账订单){
// 查询未对账订单
pos = getPOrders();
// 查询派送单
dos = getDOrders();
// 执行对账操作
diff = check(pos, dos);
// 差异写入差异库
save(diff);
} 1）上面的系统现在执行很慢，该怎样优化来执行速度呢？
目前是单线程的，那单线程的话我们就考虑是否可以用多线程来做。查询未对账订单和查询派送单这两个操作是可以并行处理的。
2）实现查询对账订单和查询派送单并行执行的代码应该是怎样的？
while(存在未对账订单){
// 查询未对账订单
Thread T1 = new Thread(()->{
pos = getPOrders();
});
T1.start();
// 查询派送单
Thread T2 = new Thread(()->{
dos = getDOrders();
});
T2.start();
// 等待T1、T2结束
T1.join();
T2.join();
// 执行对账操作
diff = check(pos, dos);
// 差异写入差异库
save(diff);
} 我们在主线程中开了两个插队的线程，等这两个查询的插队线程执行完了，阻塞的主线程被唤醒，那么就可以执行对账还有写入差异库的操作了。
3）思考一下，我们上面的代码还有没有优化的空间呢？
我们每次进行新的查询的对账的时候，都要创建两个新的线程出来，我们知道创建线程是比较好费时间的。那思考一下可不可以用线程池来减少创建线程的开销呢。
// 创建2个线程的线程池
Executor executor =
Executors.newFixedThreadPool(2);
while(存在未对账订单){
// 查询未对账订单
executor.execute(()-> {
pos = getPOrders();
});
// 查询派送单
executor.execute(()-> {
dos = getDOrders();
});
/* ？？如何实现等待？？*/
// 执行对账操作
diff = check(pos, dos);
// 差异写入差异库
save(diff);
}
4）使用上面线程池的代码的话，我的join就不能调用了，那我的主线程就不知道什么时候两个查询操作执行完了，这个时候该怎么办？
我们可以使用一个计数器，初始值呢设置为2，查询一次就减1，当两个查询执行完，那计数器就是0了，我们的主线程也就能被唤醒执行了。
5）上面的方案是我们自己想出来的，那java其实提供了一个非常方便的实现我们上面方案的工具类CountDownLatch，那使用CountDownLatch怎样优化我们的代码呢？
主线程的话我们调用await方法来阻塞，两个查询线程我们执行countDown方法，会减1。主线程当检测到为0时就可以执行了
// 创建2个线程的线程池
Executor executor =
Executors.newFixedThreadPool(2);
while(存在未对账订单){
// 计数器初始化为2
CountDownLatch latch =
new CountDownLatch(2);
// 查询未对账订单
executor.execute(()-> {
pos = getPOrders();
latch.countDown();
});
// 查询派送单
executor.execute(()-> {
dos = getDOrders();
latch.countDown();
});
// 等待两个查询操作结束
latch.await();
// 执行对账操作
diff = check(pos, dos);
// 差异写入差异库
save(diff);
}6）上面使用CountDownLatch和线程池的方案已经很不错了，在思考一下，我们的这个程序还能不能优化一下？
我的对账操作和下一次查询操作其实是不影响的，那么他们之间是可以并发执行的。也就是我在进行本次对账的同时，是可以执行下一次的查询操作的。
7）对账需要查询出数据来才可以执行，这种的话对应什么模型？
生产者-消费者模型
8）既然看出来了是生产者消费者模型，那就需要一个队列，生产者生产出来东西放到队列，消费者去队列当中取。但是针对我们上面的案例，一个队列的话肯会造成数据混乱，我们应该怎样设计？
使用两个队列，两个队列间的元素还有对应关系。订单查询操作将订单查询结果插入订单队列，派送单查询操作将派送单插入派送单队列，这两个队列的元素之间是有一一对应的关系的。我们的对账操作每次从两个队列当中各取一个，这样数据肯定不会发生混乱。
9）我们如何用代码来实现查询和对账之间的并行呢？
使用三个线程，一个线程 T1 执行订单的查询工作，一个线程 T2 执行派送单的查询工作，当线程 T1 和 T2 都各自生产完 1 条数据的时候，通知线程 T3 执行对账操作。这个想法虽看上去简单，但其实还隐藏着一个条件，那就是线程 T1 和线程 T2 的工作要步调一致，不能一个跑得太快，一个跑得太慢，只有这样才能做到各自生产完 1 条数据的时候，通知线程 T3。
10）我们上面的方案有哪些要解决的问题？怎样解决？
T1和T2要走的齐
他们执行完之后要能通知到T3
解决这两个问题的方案也很简单，还是搞一个计数器，初始化为2，T1执行完减1,T2执行完减1。当计数器值为0时，T3就可以执行了，T3执行的时候把我们计数器又重置为2,此时T1,T2又可以执行了。
11）实际项目中java其实给了我们现成的实现上面方案的工具类CyclicBarrier，代码实现的怎样的？
CyclicBarrier 的计数器有自动重置的功能，当减到 0 的时候，会自动重置你设置的初始值,所以他要带个循环
// 订单队列
Vector<P> pos;
// 派送单队列
Vector<D> dos;
// 执行回调的线程池
Executor executor =
Executors.newFixedThreadPool(1);
final CyclicBarrier barrier =
new CyclicBarrier(2, ()->{
executor.execute(()->check());
});
void check(){
P p = pos.remove(0);
D d = dos.remove(0);
// 执行对账操作
diff = check(p, d);
// 差异写入差异库
save(diff);
}
void checkAll(){
// 循环查询订单库
Thread T1 = new Thread(()->{
while(存在未对账订单){
// 查询订单库
pos.add(getPOrders());
// 等待
barrier.await();
}
});
T1.start();
// 循环查询运单库
Thread T2 = new Thread(()->{
while(存在未对账订单){
// 查询运单库
dos.add(getDOrders());
// 等待
barrier.await();
}
});
T2.start();
}