java并发编程-JAVA并发包工具: CyclicBarrier使用以及与CountDownLatch的区别，用CountDownLatch实现CyclicBarrier同样的功能

本文链接：https://blog.csdn.net/qq_27552579/article/details/112732920

CyclicBarrier

简介

允许一组线程全部等待彼此达到共同屏障点的同步辅助。循环阻塞在涉及固定大小的线程方的程序中很有用，这些线程必须偶尔等待彼此。屏障被称为循环，因为它可以在等待的线程被释放之后重新使用。

A CyclicBarrier支持一个可选的Runnable命令，每个屏障点运行一次，在派对中的最后一个线程到达之后，但在任何线程释放之前。在任何一方继续进行之前，此屏障操作对更新共享状态很有用。

实现原理：在CyclicBarrier的内部定义了一个Lock对象，每当一个线程调用await方法时，将拦截的线程数减1，然后判断剩余拦截数是否为初始值parties，如果不是，进入Lock对象的条件队列等待。如果是，执行barrierAction对象的Runnable方法，然后将锁的条件队列中的所有线程放入锁等待队列中，这些线程会依次的获取锁、释放锁。

构造方法

CyclicBarrier(int parties)
创建一个新的 CyclicBarrier ，当给定数量的线程（线程）等待它时，它将跳闸，并且当屏障跳闸时不执行预定义的动作。
CyclicBarrier(int parties, Runnable barrierAction)
创建一个新的 CyclicBarrier ，当给定数量的线程（线程）等待时，它将跳闸，当屏障跳闸时执行给定的屏障动作，由最后一个进入屏障的线程执行。

方法

int await() 等待所有 parties已经在这个障碍上调用了 await 。
int await(long timeout, TimeUnit unit) 等待所有 parties已经在此屏障上调用 await ，或指定的等待时间过去。
int getNumberWaiting() 返回目前正在等待障碍的各方的数量。
int getParties() 返回旅行这个障碍所需的parties数量。
boolean isBroken() 查询这个障碍是否处于破碎状态。
void reset() 将屏障重置为初始状态。

cyclicBarrier使用

两个线程异步执行任务，任务执行完成，通知主线程

package com.ln.juc.utils.cyclicbarrier;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.juc.utils.cyclicbarrier
 * @Name:CyclicbarrierExample1
 * @Author:linianest
 * @CreateTime:2021/1/16 16:56
 * @version:1.0
 * @Description TODO:
 */
public class CyclicBarrierExample1 {

    public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
        final CyclicBarrier cyclicBarrier = new CyclicBarrier(2, new Runnable() {
            @Override
            public void run() {
                System.out.println("all of the task finished done.");
            }
        });
        new Thread() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println("T1 finished.");
                    cyclicBarrier.await();
                    System.out.println("T1 the other thread finish done.");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(5);
                    System.out.println("T2 finished.");
                    cyclicBarrier.await();
                    System.out.println("T2 the other thread finish done.");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }.start();
//        cyclicBarrier.await();

    }
}

reset方法

将所有的状态恢复到初始化的状态，如果有await的线程，那么会抛出BrokenBarrierException异常

package com.ln.juc.utils.cyclicbarrier;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.juc.utils.cyclicbarrier
 * @Name:CyclicBarrierExample2
 * @Author:linianest
 * @CreateTime:2021/1/17 10:36
 * @version:1.0
 * @Description TODO:CyclicBarrier 将任务分步执行,reset的使用
 */

/**
 * 将所有的状态恢复到初始化的状态，如果有await的线程，那么会抛出BrokenBarrierException异常
 */
public class CyclicBarrierExample2 {
    public static void main(String[] args) throws InterruptedException {

        final CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println("T1 finished.");
                cyclicBarrier.await();
                System.out.println("T1 the other thread finish done.");
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
                System.out.println(Thread.currentThread().getName()+" be Interrupted");
            }
        },"T1").start();

        new Thread(()->{
            try {
                System.out.println("T2 finished.");
                cyclicBarrier.await();
                System.out.println("T2 the other thread finish done.");
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
                System.out.println(Thread.currentThread().getName()+" be Interrupted");
            }
        },"T2").start();
        TimeUnit.MILLISECONDS.sleep(10);
        // 将所有的状态恢复到初始化的状态，如果有await的线程，那么会抛出BrokenBarrierException异常
        System.out.println(cyclicBarrier.getNumberWaiting());
        System.out.println(cyclicBarrier.getParties());
        System.out.println(cyclicBarrier.isBroken());
        System.out.println("============");
        cyclicBarrier.reset();
        System.out.println(cyclicBarrier.getNumberWaiting());
        System.out.println(cyclicBarrier.getParties());
        System.out.println(cyclicBarrier.isBroken());

    }
}

CountDownLatch实现 CyclicBarrier

package com.ln.juc.utils.cyclicbarrier;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.juc.utils.cyclicbarrier
 * @Name:CyclicbarrierExample1
 * @Author:linianest
 * @CreateTime:2021/1/16 16:56
 * @version:1.0
 * @Description TODO:用CountDownLatch实现 CyclicBarrier
 */
public class CyclicBarrierExample3 {

    static class MyCountDownLatch extends CountDownLatch {

        private final Runnable runnable;

        MyCountDownLatch(int count, Runnable runnable) {
            super(count);
            this.runnable = runnable;
        }

        public void countDown() {
            super.countDown();
            if (getCount() == 0) {
                this.runnable.run();
            }
        }
    }

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

        final MyCountDownLatch myCountDownLatch = new MyCountDownLatch(2, new Runnable() {
            @Override
            public void run() {
                System.out.println("all of the task finished done.");
            }
        });

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myCountDownLatch.countDown();
            System.out.println(Thread.currentThread().getName() + " finished work.");
        }).start();
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myCountDownLatch.countDown();
            System.out.println(Thread.currentThread().getName() + " finished work.");
        }).start();
    }
}

CountDownLatch和CyclicBarrier的比较

CountDownLatch是线程组之间的等待，即一个(或多个)线程等待N个线程完成某件事情之后再执行；而CyclicBarrier则是线程组内的等待，即每个线程相互等待，即N个线程都被拦截之后，然后依次执行。
CountDownLatch是减计数方式，而CyclicBarrier是加计数方式。
CountDownLatch计数为0无法重置，而CyclicBarrier计数达到初始值，则可以重置。
CountDownLatch不可以复用，而CyclicBarrier可以复用。