了解join()和CountDownLatch的差异

叁歲伎倆 2022-05-18 04:04 91阅读 0赞

### 一、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);
            }
        }
    }

运行结果如下：

![70][]

显然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，没有任何交替。

![70 1][]

简单分析，是因为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()+"：他们把盘子洗完了，那我可以开始做菜了");
            }
        }
    }

下面看执行过程：

![70 2][]

可以看出厨师长在所有盘子都洗干净之后开始做菜了。也就是说，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才是合理的。

![70 3][]

[70]: /images/20220518/89c86263470749e78a88b6584c7bf18f.png
[70 1]: /images/20220518/22b81bea253b40d9a40fa31dd4fd31bd.png
[70 2]: /images/20220518/563ae2ac88ff47d7adba530bd45b836d.png
[70 3]: /images/20220518/7fceef1d918940eab60abe87675f424f.png