CountDownLatch和CyclicBarrier

1.有时主线程需要等待其他线程完成工作可以使用这种方法完成线程同步

package com.ydlclass.collection;

import com.ydlclass.lock.ThreadUtil;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(3);
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        Runnable task1 = () ->{
            ThreadUtil.sleep(5);
            System.out.println("计算账目a");
            countDownLatch.countDown();//值减1
        };

        Runnable task2 = () ->{
            ThreadUtil.sleep(5);
            System.out.println("计算账目b");
            countDownLatch.countDown();
        };

        Runnable task3 = () ->{
            ThreadUtil.sleep(5);
            System.out.println("计算账目c");
            countDownLatch.countDown();
        };

        executorService.submit(task1);
        executorService.submit(task2);
        executorService.submit(task3);
        countDownLatch.await();//此方法阻塞在这里直到，countDownLatch的值被减为0
        System.out.println("计算总账");
    }
}

2.CycleBarrier相似的使用，其中他是使用await让线程等待，等到了指定的数量之后，然后接着执行指定的线程。

import com.ydlclass.lock.ThreadUtil;

import java.util.concurrent.*;

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        Runnable mainThread = () ->{
            System.out.println("计算总账");
        };
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3,mainThread);
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        Runnable task1 = () ->{
            ThreadUtil.sleep(5);
            System.out.println("计算账目a");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        };

        Runnable task2 = () ->{
            ThreadUtil.sleep(5);
            System.out.println("计算账目b");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        };

        Runnable task3 = () ->{
            ThreadUtil.sleep(5);
            System.out.println("计算账目c");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        };

        executorService.submit(task1);
        executorService.submit(task2);
        executorService.submit(task3);

        cyclicBarrier.reset();
        executorService.submit(task1);
        executorService.submit(task2);
        executorService.submit(task3);
        
    }
}

3.两者的区别，前者只能使用一次，后者可以循环使用；