了解join()和CountDownLatch的差异

一、join()

join()是线程对象的成员方法，功能是等待调用join()的线程对象执行完毕，才执行其它的逻辑。
假设我们有三个线程， 主线程，子线程B和C。在主线程中若调用了子线程的join方法，则必须等待子线程执行完毕，才会继续执行主线程的其它逻辑。如下是案例：

public class JoinTest {
    public static void main(String [] args) throws InterruptedException {
        ThreadJoinTest t1 = new ThreadJoinTest("子线程B");
        ThreadJoinTest t2 = new ThreadJoinTest("子线程C");
        t1.start();
        t2.start();
        t1.join(); 
        t2.join();
        System.out.println("主线程运行完毕!");
    }
}
class ThreadJoinTest extends Thread{
    public ThreadJoinTest(String name){
        super(name);
    }
    @Override
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println(this.getName() + ":" + i);
        }
    }
}

运行结果如下：

显然main方法所属的主线程必须等待t1，t2执行完毕，才会继续执行最后的输出语句。那么为什么t1，t2是交替执行呢？这是因为调用t1.join()和t2.join()的线程是主线程，所以调用t1.join()时，t2不需要等待，同理调用t2.join()时，t1不需要等待。

再看main方法的另一个版本：

    public static void main(String [] args) throws InterruptedException {
        ThreadJoinTest t1 = new ThreadJoinTest("子线程B");
        ThreadJoinTest t2 = new ThreadJoinTest("子线程C");
        t1.start();
        t1.join(); 
        t2.start();
        t2.join();
        System.out.println("主线程运行完毕!");
    }

控制台输出如下，可以看出程序完全是先执行了t1，然后才执行了t2，没有任何交替。

简单分析，是因为t1.start()执行后又执行了t1.join()，此时主线程等待，t2线程还没有启动。一直等到t1完成之后，才执行了t2.start()来启动t2，然后执行t2.join()来让主线程等待，最后t2执行完毕，主线程完成最后输出。

二、CountDownLatch

CountDownLatch是一种灵活的闭锁实现，它维护了一个计数器，通过计数器控制一个或多个线程等待另一组事件发生，具体控制方法是：CountDownLatch调用countDown方法来递减计数器，表示有一个事件发生了，调用await在计数器为0之前保持阻塞。

如下是一个简单的案例：演示了两个工人，老王和老张，分别做洗碗和洗衣服的工作，每个工人洗碗后通知厨师长自己已经洗碗ok，当所有的碗都洗完了，厨师长开始做菜。我们用CountDownLatch来演示厨师长的等待过程。

public class TestCount {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(2);
        Thread worker1 = new Thread(new Worker(latch, (long) (Math.random()*2000+3000)), "老李");
        Thread worker2 = new Thread(new Worker(latch,(long) (Math.random()*2000+3000)), "老张");
        Thread worker3 = new Thread(new HeadChef(latch,(long) (Math.random()*2000+3000)), "厨师长老王");
        worker1.start();
        worker2.start();
        latch.await();
        worker3.start();
    }

    static class Worker implements Runnable {

        private CountDownLatch latch;
        private Long workingTime;


        public Worker(CountDownLatch latch, Long workingTime) {
            this.latch = latch;
            this.workingTime = workingTime;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"：开始洗盘子了");
            try {
                Thread.sleep(workingTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"：报告厨师长，盘子已洗完");
            latch.countDown();
            System.out.println(Thread.currentThread().getName()+"：开始洗衣服了");
            try {
                Thread.sleep(workingTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"：衣服已洗完");
        }
    }

    static class HeadChef extends Worker { //厨师长，也是个打工的，不过更高级点，干活少
        public HeadChef(CountDownLatch latch, Long workingTime) {
            super(latch, workingTime);
        }
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"：他们把盘子洗完了，那我可以开始做菜了");
        }
    }
}

下面看执行过程：

可以看出厨师长在所有盘子都洗干净之后开始做菜了。也就是说，await成功地控制了worker3的执行时机，在worker1和worker2执行洗碗工作完成之后，才开始执行炒菜工作。

要注意：案例中洗碗和洗衣服分别是不同的两个事件，而worker1和worker2线程要执行的内容就是执行这两个事件。worker3线程执行的内容是等待worker1和worker2完成洗碗事件之后，才开始做菜这个事件。

三、join()和CountDownLatch的区别和联系

join()的阻塞原理是不停检查join()所属的线程对象是否存活（也就是线程完全执行完毕），如果存活则让调用join()的线程保持阻塞。

CountDownLatch的阻塞原理是仅仅关注计数器是否为0，若为0才保持阻塞，它并不关注持有计数器的其它线程是否完全执行完毕。

显然join()能控制阻塞的范围比CountDownLatch小，且没有CountDownLatch那么灵活。

我们将第二个案例main改造成使用join()就能看出区别：

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(2);
        Thread worker1 = new Thread(new Worker(latch, (long) (Math.random()*2000+3000)), "老李");
        Thread worker2 = new Thread(new Worker(latch,(long) (Math.random()*2000+3000)), "老张");
        Thread worker3 = new Thread(new HeadChef(latch,(long) (Math.random()*2000+3000)), "厨师长老王");
        worker1.start();
        worker2.start();
//        latch.await();
        worker1.join();
        worker2.join();
        worker3.start();
    }

通过join()控制了老张和老李所有工作做完了，老王才开始工作。显然这种场景下，老王浪费了很多不必要的时间，作为一个厨师长，他不需要关注衣服有没有洗完，而只需要关注盘子洗完了没有，所以此处使用CountDownLatch才是合理的。