java:用CountDownLatch.await替代Object.wait实现线程阻塞/唤醒

线程之间经常需要一定的同步，比如线程A需要线程B的部分运算结果，但又不必等到线程B把所有的结果都算出来，否则A就要待太长时间。
下面这个例子就是这个应用场景，主线程需要等待子线程从数据库中加载记录，但是子线程把所有的记录都加载完要花挺长时间。
而实际上，主线程最开始只需要一条记录就可以继续自己的后续动作了。怎么办呢？下面的代码利用传统的Object.wait()/nofity()方法来实现：

    public void openSource() {        // 创建一个初值为1的倒数计数器对象作为通知对象        Object notifier=new Object();        // 启动新线程用于长时间的加载任务        new Thread(new Runnable() {            @Override            public void run() {                boolean isNotified=false;                try {                    int index = 0;                                      while (true) {                        {                        // 加载数据。。。。                        }                        // 加载第一条记录后，唤醒等待线程                        if (1 == ++index) {                            synchronized (notifier){                                notifier.notify();                                isNotified=true;                            }                                                   }                    }                } finally {                    //循环结束，不论有没有加载到数据记录，都执行唤醒,                    //以确保notify无论如何都会被执行一次，否则等待线程会一直阻塞                     synchronized (notifier){                        if(!isNotified)                            notifier.notify();                    }                }            }        }).start();             synchronized (notifier){            try {                // 启动子线程后立即阻塞， 等待被子线程唤醒                notifier.wait();            } catch (InterruptedException e) {}        }        // 确保子线程加载了第一记录后，主线程继续自己的工作。。。。    }

话说，用Object.wait()/notify()倒是挺直观，但是，这synchronized同步块代码写起来实在有点啰嗦，我是个一行代码都不想多写的懒人。
就在想这代码能不能 看着更简单点？
于是想到了java.util.concurrent包下的CountDownLatch，
这是个好东西，顾名思义，它实现了一个多线程环境下倒数计数器锁，当计数器倒数到0时，唤醒阻塞的线程，允许多个线程同时对计数器减1,用在这里实在大材小用了。不过管它呢，方便就成啊。
于是前面的代码就被我用CountDownLatch改造成下面这样：

    public void openSource() {        // 创建一个初值为1的倒数计数器锁        CountDownLatch notifier=new CountDownLatch(1);        new Thread(new Runnable() {            @Override            public void run() {                try {                    int index = 0;                    while (true) {                        {                        // 加载数据。。。。                        }                                               if (1 == ++index) {                            // 计数减1,唤醒等待线程                            notifier.countDown();                        }                    }                } finally {                    // 线程结束之前再执行一次唤醒动作                    notifier.countDown();                }            }        }).start();        try {            // 启动子线程后立即阻塞， 等待被倒数计数器锁唤醒            notifier.await();        } catch (InterruptedException e) {}    }

相比前面的代码，finally{}代码块中没有再判断是否已经执行过唤醒动作，为什么呢，因为countDown当计数已经归0的时候什么也不做，所以就算多执行一次countDown也完全不影响程序的逻辑。
没有烦人的synchronized同步块代码块后，代码是不是看起来简洁一点点呢？
当然相比原始的wait/nofity,CountDownLatch的实现是经过高度封装的代码，最终它也是用wait/nofity来实现的，但逻辑更复杂，所以性能上有多少影响我并不清楚，因为我的应用环境是在程序初始化的时候，并不是高频调用，所以我并不太关注这个。