CountDownLatch等待多线程完成，该工具类适用于主线程等待其他子线程结束后再执行的场景

public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);// 初始化线程个数
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("第一个子线程countDown");
                countDownLatch.countDown();// 线程个数减一
                System.out.println("第一个线程继续运行");
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第一个线程继续运行");
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("第二个子线程countDown");
                countDownLatch.countDown();// 线程个数减一
                System.out.println("第二个线程继续运行");
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第二个线程继续运行");
            }
        }).start();
        countDownLatch.await();
        System.out.println("主线程执行结束");
    }
}

运行结果

第二个子线程countDown
第一个子线程countDown
第二个线程继续运行
第一个线程继续运行
主线程执行结束
第一个线程继续运行
第二个线程继续运行

CyclicBarrier 可循环使用的屏障，使一组线程都达到屏障点的时候才放行。

public class CyclicBarrierTest implements Runnable {
    // 屏障数为4，下面4个子线程都执行到屏障点的时候才放行，this为放行后执行的线程，该线程执行完后才继续执行各个子线程
    private CyclicBarrier cyclicBarrier = new CyclicBarrier(4,this);

    private Executor executor = Executors.newFixedThreadPool(4);
    public AtomicInteger count = new AtomicInteger(0);


    private void count() {
        for(int i = 0;i<4;i++){
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0;j<10;j++) {
                        count.getAndIncrement();
                    }
                    try {
                        System.out.println("子线程等待");
                        cyclicBarrier.await();
                        System.out.println("子线程结束");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    @Override
    public void run() {
        System.out.println("阻塞线程执行");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计数结果："+count.get());
        System.out.println("阻塞线程结束");
    }

    public static void main(String[] args) {
        CyclicBarrierTest test =new CyclicBarrierTest();
        test.count();
    }

}

CountDownLatch和CyclicBarrier的区别

CountDownLatch : （一个或者多个等待N个）一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行。对于CountDownLatch来说，重点是那个“一个线程”, 是它在等待， 而另外那N的线程在把“某个事情”做完之后可以继续等待，可以终止。

CyclicBarrier: （N个线程相互等待）任何一个线程完成之前，所有的线程都必须等待。重点是那N个线程，他们之间任何一个没有完成，所有的线程都必须等待。