Java并发编程——CyclicBarrier

兵部尚输

 关注

阅读 112

2023-02-01

一、CyclicBarrier循环栅栏

  • CyclicBarrier是java.util.concurrent包下面的一个工具类，字面意思是可循环使用（Cyclic）的屏障（Barrier），通过它可以实现让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，所有被屏障拦截的线程才会继续执行。

  • CyclicBarrier循环栅栏和CountDownLatch很类似，都能阻塞一组线程

  • 栅栏类似于闭锁，它能阻塞一组线程直到某个事件的发生。栅栏与闭锁的关键区别在于，所有的线程必须同时到达栅栏位置，才能继续执行。闭锁用于等待事件，而栅栏用于等待其他线程。

  • CyclicBarrier可以使一定数量的线程反复地在栅栏位置处汇集。当线程到达栅栏位置时将调用await方法，这个方法将阻塞直到所有线程都到达栅栏位置。如果所有线程都到达栅栏位置，那么栅栏将打开，此时所有的线程都将被释放，而栅栏将被重置以便下次使用。

上面5只小熊，准备跑到起跑线，跑到起跑线等待，相当于执行了await方法，等到所有小熊准备就绪之后，然后一起开跑。这就很好的揭示了内存屏障的作用了。

二、执行原理

CyclicBarrier是基于ReentrantLock的Condition来实现的。

如下图，栅栏中有两个关键属性：

  • parties：栅栏计数器初始值
  • count：栅栏计数器

其中CyclicBarrier的await()方法封装了对ReentrantLock条件锁的使用，主要处理流程：

  • 获取ReentrantLock锁；
  • count减1，如果此时count为0，那么唤醒等待队列中所有线程，并结束这一轮处理，重置屏障，否则进入下一步；
  • 执行condition.await方法，把当前线程丢到条件队列；
  • 当count减少到0的时候，执行condition.signalAll方法把条件队列中的所有线程节点都移动到等待队列；
  • 最后唤醒同步队列中的线程节点，线程从condition.await阻塞处醒来继续执行：获取ReentrantLock锁，用当前线程节点替换旧的头节点，最终放ReentrantLock锁，继续让线程往下执行(每个线程依次获取、锁释放锁)。如下图：

await()能够响应中断。除此之外，await还提供了带有超时的实现await(long timeout, TimeUnit unit)，以及reset()方法重新开启下一轮。

三、CyclicBarrier的用法

3.1 CyclicBarrier构造方法

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

3.2 CyclicBarrier方法

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

3.3 CyclicBarrier使用

/**
 * @Description: 演示CyclicBarrier的使用
 */
public class CyclicBarrierDemo {

    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> {
            System.out.println("所有人都到场了，大家统一出发");
        });

        for (int i = 0; i < 10; i++) {
            final int id = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName()+"，id："+id+"现前往集合地点");
                try {
                    Thread.sleep(new Random().nextInt(10000));
                    System.out.println(Thread.currentThread().getName()+"到了集合地点，开始等待其他人到达");
                    cyclicBarrier.await();
                    System.out.println(Thread.currentThread().getName()+"出发了");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

3.4 CyclicBarrier和CountDownLatch的区别

  • 作用不同：CyclicBarrier要等固定数量的线程都到达了栅栏位置才能继续执行，而CountDownLatch只需要等待数字到0，也就是说，CountDownLatch用于事件，CyclicBarrier是用于线程的
  • 可重用性不同：CountDownLatch在倒数到0并触发门闩打开后，就不能再次使用了，除非新建实例；而CyclicBarrier可以重复使用
  • CountDownLatch是减计数方式，而CyclicBarrier是加计数方式。
  • CountDownLatch计数为0无法重置，而CyclicBarrier计数达到初始值，则可以重置。

四、源码

CyclicBarrier是由ReentrantLock可重入锁和Condition共同实现的。

4.1 CyclicBarrier构造方法

public class CyclicBarrier {

    //同步操作锁
    private final ReentrantLock lock = new ReentrantLock();
	
    //线程拦截器
    private final Condition trip = lock.newCondition();
	
    //每次拦截的线程数
    private final int parties;
	
    //换代前执行的任务
    private final Runnable barrierCommand;
	
    //表示栅栏的当前代
    private Generation generation = new Generation();
	
	//计数器
	private int count;
	
	//静态内部类Generation
    private static class Generation {
        boolean broken = false;
    }
	
    public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
		// parties表示“必须同时到达barrier的线程个数”。
        this.parties = parties;
		// count表示“处在等待状态的线程个数”。
        this.count = parties;
		// barrierCommand表示“parties个线程到达barrier时，会执行的动作”。
        this.barrierCommand = barrierAction;
    }
}

4.2 await源码分析

public class CyclicBarrier {

    public int await() throws InterruptedException, BrokenBarrierException {
        try {
            return dowait(false, 0L);
        } catch (TimeoutException toe) {
            throw new Error(toe); // cannot happen
        }
    }
}

public class CyclicBarrier {

    private int dowait(boolean timed, long nanos)
        throws InterruptedException, BrokenBarrierException,
               TimeoutException {
        final ReentrantLock lock = this.lock;
		// 获取“独占锁(lock)”
        lock.lock();
        try {
			// 保存“当前的generation”
            final Generation g = generation;

			// 若“当前generation已损坏”，则抛出异常。
            if (g.broken)
                throw new BrokenBarrierException();

			// 如果当前线程被中断，则通过breakBarrier()终止CyclicBarrier，唤醒CyclicBarrier中所有等待线程。
            if (Thread.interrupted()) {
                breakBarrier();
                throw new InterruptedException();
            }

			// 将“count计数器”-1
            int index = --count;
			// 如果index=0，则意味着“有parties个线程到达barrier”。
            if (index == 0) {  // tripped
                boolean ranAction = false;
                try {
                    final Runnable command = barrierCommand;
					// 如果barrierCommand不为null，则执行该动作。
                    if (command != null)
                        command.run();
                    ranAction = true;
					// 唤醒所有等待线程，并更新generation。
                    nextGeneration();
                    return 0;
                } finally {
                    if (!ranAction)
                        breakBarrier();
                }
            }

            // 当前线程一直循环，直到“有parties个线程到达barrier” 或 “当前线程被中断” 或 “超时”这3者之一发生，
			// 当前线程才继续执行。
            for (;;) {
                try {
					// 如果不是“超时等待”，则调用await()进行等待；否则，调用awaitNanos()进行等待。
                    if (!timed)
                        trip.await();
                    else if (nanos > 0L)
                        nanos = trip.awaitNanos(nanos);
                } catch (InterruptedException ie) {
					// 如果等待过程中，线程被中断，则执行下面的函数。
                    if (g == generation && ! g.broken) {
                        breakBarrier();
                        throw ie;
                    } else {
                        // We're about to finish waiting even if we had not
                        // been interrupted, so this interrupt is deemed to
                        // "belong" to subsequent execution.
                        Thread.currentThread().interrupt();
                    }
                }
				// 如果“当前generation已经损坏”，则抛出异常。
                if (g.broken)
                    throw new BrokenBarrierException();
				// 如果“generation已经换代”，则返回index。
                if (g != generation)
                    return index;
				// 如果是“超时等待”，并且时间已到，则通过breakBarrier()终止CyclicBarrier，
				// 唤醒CyclicBarrier中所有等待线程，并抛出TimeoutException异常
                if (timed && nanos <= 0L) {
                    breakBarrier();
                    throw new TimeoutException();
                }
            }
        } finally {
			// 释放“独占锁(lock)”
            lock.unlock();
        }
    }
}

参考： https://www.itzhai.com/articles/graphical-several-fun-concurrent-helper-classes.html

https://www.cnblogs.com/200911/p/6060195.html

相关推荐

并发编程：CyclicBarrier

流沙雨帘 106 0 0

并发编程--CyclicBarrier屏障

夏侯居坤叶叔尘 82 0 0

并发编程-CyclicBarrier屏障

诗与泡面 52 0 0

Java并发编程之栅栏(CyclicBarrier)详解

兮城 77 0 0

Java并发之CyclicBarrier

夜空一星 125 0 0

Java并发编程之并发工具类CountDownLatch，CyclicBarrier，Semaphore详解

快乐小码农 73 0 0

并发类编程—CyclicBarrier(循环屏蔽)

无愠色 33 0 0

并发编程之 CountDownLatch &CyclicBarrier & Exchanger

一世独秀 122 0 0

java基础-并发编程-CyclicBarrier（JDK1.8）源码学习

草原小黄河 34 0 0

Java并发基础：CyclicBarrier全面解析！

诗与泡面 13 0 0

精彩评论（0）

0 0 举报