并发编程大师系列之：CountDownLatch和Join

业务场景描述：假设一条流水线上有三个工作者：worker1，worker2，worker3。有一个任务的完成需要他们三者协作完成，worker3可以开始这个任务的前提是worker1和worker2完成了他们的工作，而worker1和worker2是可以并行他们各自的工作的。

1.join实现

public class CountDownLatchAndJoin {

    public static void main(String[] args) throws InterruptedException {

        // 三个独立的工人线程

        worker worker1 = new worker("worker1", (long) (Math.random()*4000));

        worker worker2 = new worker("worker2", (long) (Math.random()*4000));

        worker worker3 = new worker("worker3", (long) (Math.random()*4000));

//        worker worker1 = new worker("worker1", 6000);

//        worker worker2 = new worker("worker2", 5000);

//        worker worker3 = new worker("worker3", 5000);

        worker1.start();

        worker2.start();

        worker1.join();

        worker2.join();

        System.out.println("准备工作就绪...");

        worker3.start();

    }

    // 工人类

    public static class worker extends Thread {

        // 名字

        private String name;

        //工作时间

        private long time;

        worker(String name, long time) {

            this.name = name;

            this.time = time;

        }

        public void run() {

            try {

                System.out.println(name + "开始工作");

                Thread.sleep(time);

                System.out.println(name + "工作完成，耗费时间=" + time);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

}

结果：

worker2开始工作

worker1开始工作

worker1工作完成，耗费时间=601

worker2工作完成，耗费时间=2886

准备工作就绪...

worker3开始工作

worker3工作完成，耗费时间=686

可以顺利的完成工作，join的工作原理是，不停检查thread是否存活，如果存活则让当前线程永远wait，直到thread线程终止，线程的notifyAll就会被调用，还可以理解为join就是插队的意思

2.CountDownLatch实现

public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {

        // 初始化计数器为2

        CountDownLatch countDownLatch = new CountDownLatch(2);

        // 三个独立的工人线程

        worker worker1 = new worker("worker1", (long) (Math.random() * 4000), countDownLatch);

        worker worker2 = new worker("worker2", (long) (Math.random() * 4000), countDownLatch);

        worker worker3 = new worker("worker3", (long) (Math.random() * 4000), countDownLatch);

        worker1.start();

        worker2.start();

        // 当计数器不为0的时候均等待

        countDownLatch.await();

        System.out.println("准备工作就绪...");

        worker3.start();

    }

    public static class worker extends Thread {

        private String name;

        private long time;

        private CountDownLatch countDownLatch;

        worker(String name, long time, CountDownLatch countDownLatch) {

            this.name = name;

            this.time = time;

            this.countDownLatch = countDownLatch;

        }

        public void run() {

            System.out.println(name + " 开始工作了。。。");

            // 减一

            countDownLatch.countDown();

            System.out.println(name + " 工作完成。。。");

        }

    }

}

创建一个计数器为2的 CountDownLatch ，让Worker持有这个CountDownLatch 实例，当完成自己的工作后，调用countDownLatch.countDown() 方法将计数器减1。countDownLatch.await() 方法会一直阻塞直到计数器为0，主线程才会继续往下执行。

运行结果：

worker1 开始工作了。。。

worker1 工作完成。。。

worker2 开始工作了。。。

worker2 工作完成。。。

准备工作就绪...

worker3 开始工作了。。。

worker3 工作完成。。。

从结果上来看，都解决了问题，但是他们的区别在哪里呢？

业务场景：假设worker的工作可以分为两个阶段，work3 只需要等待work1和work2完成他们各自工作的第一个阶段之后就可以开始自己的工作了，而不是场景1中的必须等待work1和work2把他们的工作全部完成之后才能开始。这样join就不可以实现了，应当采用CountDownLatch 来实现。

public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {

        // 初始化计数器为5

        CountDownLatch countDownLatch = new CountDownLatch(5);

        // 三个独立的工人线程

        worker worker1 = new worker("worker1", (long) (Math.random() * 4000), countDownLatch);

        worker worker2 = new worker("worker2", (long) (Math.random() * 4000), countDownLatch);

        worker worker3 = new worker("worker3", (long) (Math.random() * 4000), countDownLatch);

        worker worker4 = new worker("worker4", (long) (Math.random() * 4000), countDownLatch);

        worker worker5 = new worker("worker5", (long) (Math.random() * 4000), countDownLatch);

        worker worker6 = new worker("worker6", (long) (Math.random() * 4000), countDownLatch);

        worker1.start();

        worker2.start();

        worker3.start();

        worker4.start();

        worker5.start();

        // 当计数器不为0的时候均等待

        countDownLatch.await();

        System.out.println("准备工作就绪...");

        worker6.start();

    }

    public static class worker extends Thread {

        private String name;

        private long time;

        private CountDownLatch countDownLatch;

        worker(String name, long time, CountDownLatch countDownLatch) {

            this.name = name;

            this.time = time;

            this.countDownLatch = countDownLatch;

        }

        public void run() {

            try {

                System.out.println(name + " 工作开始。。。");

                Thread.sleep(time);

                System.out.println(name + " 第一阶段工作完成。。。用时:" + time);

                // 计数器减一

                countDownLatch.countDown();

                // 假设第二阶段的工作都需要两秒完成

                Thread.sleep(2000);

                System.out.println(name + " 第二阶段工作完成。。。用时:" + (time + 2000));

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

}

多运行几次发现：线程6等到前面5个线程的第一阶段全部完成，就开始运行了，运行结果：

worker3 工作开始。。。

worker2 工作开始。。。

worker1 工作开始。。。

worker4 工作开始。。。

worker5 工作开始。。。

worker3 第一阶段工作完成。。。用时:1410

worker5 第一阶段工作完成。。。用时:2022

worker2 第一阶段工作完成。。。用时:2273

worker1 第一阶段工作完成。。。用时:2856

worker3 第二阶段工作完成。。。用时:3410

worker4 第一阶段工作完成。。。用时:3430

准备工作就绪...

worker6 工作开始。。。

worker5 第二阶段工作完成。。。用时:4022

worker2 第二阶段工作完成。。。用时:4273

worker1 第二阶段工作完成。。。用时:4856

worker4 第二阶段工作完成。。。用时:5430

worker6 第一阶段工作完成。。。用时:3773

worker6 第二阶段工作完成。。。用时:5773

总结：调用thread.join() 方法必须等thread 执行完毕，当前线程才能继续往下执行，而CountDownLatch通过计数器提供了更灵活的控制，只要检测到计数器为0当前线程就可以往下执行而不用管相应的thread是否执行完毕。

巴特西

并发编程大师系列之：CountDownLatch和Join

最新文章

热门文章