深入理解 CyclicBarrier【源码分析】

已于 2024-04-12 19:24:01 修改
阅读量518 收藏 3
点赞数 11
分类专栏： 【JUC源码】 文章标签： java 多线程 并发编程 CyclicBarrier CAS
于 2024-04-12 09:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42118323/article/details/137550088
版权

CyclicBarrier 概念：

CyclicBarrier 字面意思是环栅栏，是 JUC 下的一个并发工具，跟 CountDownLatch 很相似，都可以使线程先等待然后再执行，但是它的功能比 CountDownLatch 更加复杂和强大， CountDownLatch 是一个或者多个线程等待另外一批线程执行完毕后，在接着执行，而 CyclicBarrier 是等待一批线程到达某个状态之后再同时开始执行，回环的意思是当所有的线程被释放后，CyclicBarrier 可以被重启，也就是可以重复使用。

知识储备传送门：

深入理解 AbstractQueuedSynchronizer（AQS）【源码分析】
深入理解 ReentrantLock 【源码分析】
CAS的使用以及底层原理详解
深入理解 CountDownLatch 【源码分析】

CyclicBarrier 属性、构造方法源码分析：

public class CyclicBarrier {
    
	//内部类 每次使用CyclicBarrier 都会生成一个Generation实例 每当屏障被处罚或者重置时候 对应的Generation就会发生变化
    private static class Generation {
        boolean broken = false;
    }

	//ReentrantLock 重入锁 保护屏障入口的锁
    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;

    //更新屏障行程状态并唤醒所有线程 仅在持有锁时调用 是开启下一代的方法
    private void nextGeneration() {
        // signal completion of last generation
		//唤醒所有线程
        trip.signalAll();
        // set up next generation
		//恢复count值，开启新的一代
        count = parties;
        generation = new Generation();
    }

   //将当前屏障生成设置为已破坏并唤醒所有线程 仅在持有锁时调用。
    private void breakBarrier() {
		//将这一代中的 broken 设置为true  表示这一代是被打破了的 再来到这一代的线程  直接抛出异常
        generation.broken = true;
		//重置 count
        count = parties;
		//唤醒所有线程 调用的是 AbstractQueuedLongSynchronizer.ConditionObject#signalAll
        trip.signalAll();
    }
	
	//构造方法
	public CyclicBarrier(int parties, Runnable barrierAction) {
		//如果拦截的线程数量小于0 就抛出异常
        if (parties <= 0) throw new IllegalArgumentException();
		//拦截的线程数量等于传入的数量
        this.parties = parties;
		//还要等待的线程数量
        this.count = parties;
		//设置所有线程都到达屏障位置要执行的操作
        this.barrierCommand = barrierAction;
    }

    //构造方法 创建拦截指定数量线程的CyclicBarrier
    public CyclicBarrier(int parties) {
        this(parties, null);
    }
}

类属性解析：

  • Generation：代，在 CyclicBarrier 中同一批线程属于同一代，当屏障拦截的线程数 parties 都到达屏障前，此时会更新到下一代，broken 标识当前代的状态，默认 false ，false 表示没有被打破，true 表示被打破了。
  • parties：屏障拦截的线程数。
  • count：没有达到屏障前的线程数，也就是要等待的线程数。
  • trip ：等待屏障触发的条件，用于线程的等待或者唤醒。
  • lock ：重入锁，保护屏障入口的锁。
  • barrierCommand：屏障将要放开的时候执行的操作，也就是所有等待的线程都到达屏障了之后的操作。
  • nextGeneration：开启下一代的方法，并唤醒所有等待的线程。
  • breakBarrier：将当前屏障生成设置为已破坏，并唤醒所有线程，仅在持有锁时才能调用。

AbstractQueuedLongSynchronizer.ConditionObject#signalAll 方法源码分析：

//AbstractQueuedLongSynchronizer.ConditionObject#signalAll 唤醒所有的线程
public final void signalAll() {
	//当前线程是否占有锁 必须占有锁才可以调用  doSignalAll 方法
	if (!isHeldExclusively())
		throw new IllegalMonitorStateException();
	//获取头节点
	Node first = firstWaiter;
	//头节点不为空 表示是正常的条件队列
	if (first != null)
		//执行唤醒操作
		doSignalAll(first);
}

//java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject#doSignalAll 删除并转移所有节点 其实就是唤醒所有节点并删除
private void doSignalAll(Node first) {
	//最后一个节点 第一个节点都赋值为 null
	lastWaiter = firstWaiter = null;
	//循环唤醒节点
	do {
		//获取头节点的下一个节点
		Node next = first.nextWaiter;
		//头节点的下一个赋值为 null
		first.nextWaiter = null;
		//
		transferForSignal(first);
		first = next;
	} while (first != null);
}

//java.util.concurrent.locks.AbstractQueuedLongSynchronizer#transferForSignal 将节点从条件队列传输到同步队列 如果成功则返回 true。
final boolean transferForSignal(Node node) {
	
	//将节点状态设置为 0 
	if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
		//设置失败 
		return false;

   
	//将当前节点添加到同步阻塞队列中 AQS 源码中分析过  enq 方法
	Node p = enq(node);
	//获取节点的状态
	int ws = p.waitStatus;
	//状态大于0 表示节点已经取消了 或者尝试设置节点P的状态为 SIGNAL 失败了(表示下一个节点要停止阻塞 需要唤醒他了) 
	if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
		//唤醒当前线程上的节点
		LockSupport.unpark(node.thread);
	return true;
}

//AbstractQueuedLongSynchronizer#enq 初始化队列 并把node 节点加入队列作为队列的尾节点
private Node enq(final Node node) {
	//自旋
	for (;;) {
		//把尾节点 赋值给 t
		Node t = tail;
		//判断尾节点是否为空
		if (t == null) { // Must initialize
			//尾节点为空 创建一个新的空节点 并使用 CAS 将创建的空节点设置为队列头节点
			if (compareAndSetHead(new Node()))
				//头节点设置成功后 也就是队列初始化成功后 把队列的尾节点也指向刚刚创建的空的头节点
				tail = head;
		} else {
			//尾节点不为空 表示队列初始化完成了 至少是第二次循环了  将node节点的前驱指针指向当前队列的尾节点
			node.prev = t;
			//使用 CAS 用设置node 节点为新的尾节点
			if (compareAndSetTail(t, node)) {
				//设置成功后 将之前的尾节点 t 的后驱指针指向 node 节点
				t.next = node;
				//node 节点成功加入到队列尾部 
				return t;
			}
		}
	}
}

CyclicBarrier #await 方法源码分析：

调用 await 方法的线程告诉 CyclicBarrier 我已经到达屏障位置，然后阻塞当前线程等待其他线程的到来，CyclicBarrier 提供带超时的 await 方法和不带超时时间的await方法，这两个方法最后都会调用 dowait 方法。

//不带超时的await方法
public int await() throws InterruptedException, BrokenBarrierException {
	try {
		//真正干活的方法
		return dowait(false, 0L);
	} catch (TimeoutException toe) {
		throw new Error(toe); // cannot happen
	}
}

//带超时时间的 await 方法
public int await(long timeout, TimeUnit unit)
	throws InterruptedException,
		   BrokenBarrierException,
		   TimeoutException {
	return dowait(true, unit.toNanos(timeout));
}

CyclicBarrier #dowait方法源码分析：

dowait 方法是真正做到让线程在屏障前等待的方法，也是 CyclicBarrier 的核心方法。

//实现 栅栏/屏障的核心方法
private int dowait(boolean timed, long nanos)
	throws InterruptedException, BrokenBarrierException,
		   TimeoutException {
	//获取重入锁
	final ReentrantLock lock = this.lock;
	//锁定
	lock.lock();
	try {
		//获取当前代
		final Generation g = generation;

		//为ture 表示这一代是被打破了的 抛出异常
		if (g.broken)
			throw new BrokenBarrierException();
		//获取当前线程的打断状态 
		if (Thread.interrupted()) {
			//状态是被打断了的 将当前这一代设置为破坏了的 唤醒所有等待的线程  breakBarrier 源码上面分析过
			breakBarrier();
			//抛出异常
			throw new InterruptedException();
		}

		//count 还能阻塞的线程减一
		int index = --count;
		if (index == 0) {  // tripped
			//如果还能阻塞的线程为0 表示这是最后一个线程了 其他的线程都到了 栅栏/屏障前了
			//任务是否被执行的标志
			boolean ranAction = false;
			try {
				//所有线程到达栅栏/屏障前要执行的操作
				final Runnable command = barrierCommand;
				if (command != null)
					//不为空 则开始执行
					command.run();
				//任务执行标志被设置为 false
				ranAction = true;
				//进入下一代 nextGeneration 方法上面分析过源码
				nextGeneration();
				//返回
				return 0;
			} finally {
				//所有线程到达栅栏/屏障前要执行的操作发生了异常要走到这里来
				if (!ranAction)
				   //任务没有被执行   将当前这一代设置为破坏了的 唤醒所有等待的线程  breakBarrier 源码上面分析过
					breakBarrier();
			}
		}

		// loop until tripped, broken, interrupted, or timed out
		//自旋 非最后一个线程会走到这里来
		for (;;) {
			try {
				// 没有等待超时时间 false 有等待超时时间 true
				if (!timed)
					//没有等待超时时间 等待直到被唤醒
					trip.await();
				else if (nanos > 0L)
					//超时时间大于0 等待
					nanos = trip.awaitNanos(nanos);
			} catch (InterruptedException ie) {
				//中断异常
				if (g == generation && ! g.broken) {
					//当前代没有变化 且当前代没有被打断  则将当前屏障设置为已破坏 打断屏障
					breakBarrier();
					throw ie;
				} else {
					//当前代发生了变化 或者 代已经被打破了
					//代发生了变化 那表示进入了下一代  唤醒后走正常逻辑 标记一下中断过
					//代没有发生变化 但是代已经被打破了 记录下中断标记
					Thread.currentThread().interrupt();
				}
			}
			//来到这里的几种可能
			//开启了新一代 broken breakBarrier 方法会把 broken 设置为true 唤醒所有等待的线程
			//等待超时 获取到锁后 也会走到这里 
			
			//当前代的打破情况
			if (g.broken)
				//被打破 抛出异常
				throw new BrokenBarrierException();

			if (g != generation)
				//当前代已经发生了变化 表示最后一个线程到位了 触发了下一代的逻辑 因此要唤醒 条件队列中的所有线程
				//返回当前线程的 index
				return index;
			if (timed && nanos <= 0L) {
				//有等待时间 且等待时间小于等于0 那当前线程就不等了 打破规则 屏障
				breakBarrier();
				//抛出超时异常
				throw new TimeoutException();
			}
		}
	} finally {
		//解锁
		lock.unlock();
	}
}

CyclicBarrier #reset 方法源码分析：

//重置栅栏/屏障
public void reset() {
	//获取重入锁
	final ReentrantLock lock = this.lock;
	//锁定
	lock.lock();
	try {
		//打破屏障(当前代) 并唤醒所有的线程
		breakBarrier();   // break the current generation
		//进入下一代
		nextGeneration(); // start a new generation
	} finally {
		lock.unlock();
	}
}

我们知道 CyclicBarrier 具备重用功能，reset 方法就是实现重用功能的实现，可以看到重用功能的代码实现非常简单，就是打破屏障进入下一代即可。

CyclicBarrier 总结：

  • CyclicBarrier#await 方法会让一组线程停留在栅栏/屏障处，只有当大家都到了栅栏/屏障处，才会打开栅栏同时往下走。
  • CyclicBarrier 和 CountDownLatch、Semaphore 不一样，没有直接使用 AQS，而是基于 ReentrantLock 及 Condition 来实现的。

如有错误的地方欢迎指出纠正。

CyclicBarrier源码解读
桐花思雨
04-14 354
目录认识`CountDownLatch``CountDownLatch` 应用场景`CountDownLatch` 核心方法`CountDownLatch` 使用举例认识 `CyclicBarrier``CyclicBarrier` 源码`CountDownLatch` 和 `CyclicBarrier`共同点不同点 认识CountDownLatch CountDownLatch 是 java.util.concurrent 包下面的多线程工具类 CountDownLatch：用给定的计数初始化，awai
Java并发编程(十六)：CyclicBarrier源码分析
黄智霖的博客
04-21 4639
CyclicBarrier可以建立一个屏障，这个屏障可以阻塞一个线程直到指定的所有线程都达到屏障。就像团队聚餐，等所有人都到齐了再一起动筷子。根据Cyclic就可以发现CyclicBarrier可以重复使用。现在有了前面分析ReentrantLock、Semaphore、CountDownLatch的经验，CyclicBarrier也不复杂了，只是这里又引入新的概念：Condition条件队列，这也是最开始我们分析AQS没有讲的东西。
源码分析-CyclicBarrier
千念飞羽的专栏
02-16 3022
CyclicBarrier从用法上来说，CyclicBarrier可能看出是CountDownLatch的高级版本，增加了重置的功能，对于多个线程的中断提供了通知的功能。具体的用法通过api就有比较详细的介绍。内部类Generation-如何实现重置功能的首先CyclicBarrier内部有一个内部静态类Generation。当然在每个CyclicBarrier实例中也有一个Generation域这
CyclicBarrier 源码分析
xuwenjingrenca的博客
10-28 148
使用 public static void main(String[] args) { CyclicBarrier cyclicBarrier = new CyclicBarrier(3); System.out.println("hahaha"); for (int i=0; i<3; i++) { new Worker(cyclicBarrier).start(); } System.out.
【并发编程】CyclicBarrier 源码分析
yhl_jxy的博客
02-14 948
等待/通知模型、屏障等。
CyclicBarrier源码分析
sermonlizhi的博客
02-24 556
一、简介 在理解CyclicBarrier之前，最好先熟悉一下CountDownLatch的工作原理，这两个工具类都能达到线程等待的效果，但它们的侧重点有所不同，CountDownLatch只能使用一次，当它的计数器为0时会去唤醒所有同步队列中等待的线程，之后就不可用了。而CyclicBarrier的计数器可以被重置，达到重复使用的效果，所以它也就更适用于复杂的业务场景，比如如果计算发生错误时，可以通过重置计算器，让线程重复执行一次 CyclicBarrier：回环栅栏（循环屏障），通过它可以实现让一组线程
深入解析Java并发：CyclicBarrier源码剖析
"Java并发系列之CyclicBarrier源码分析" CyclicBarrier是Java并发编程中的一个强大工具，它允许一组线程互相等待，直到所有线程都达到一个共同的屏障点，然后一起继续执行。这个类是Java.util.concurrent包的一部分...
【Java并发编程终极指南】：深入理解CyclicBarrier的10大使用场景及高级特性
[【Java并发编程终极指南】：深入理解CyclicBarrier的10大使用场景及高级特性](https://dz2cdn1.dzone.com/storage/temp/15570003-1642900464392.png) # 1. Java并发编程基础 在现代软件开发中，多线程和并发编程...
CyclicBarrier源码深入剖析
小伍的程序之路
05-17 271
1 前言 CyclicBarrier是一种同步工具，它允许一组线程在到达一个公共的屏障点时阻塞等待，直到最后一个线程到达屏障点，屏障才能开启，此时所有被阻塞线程才能被唤醒从而继续执行。CyclicBarrier是一个可循环利用（cyclic）的的屏障（barrier）,与CountDownLatcher相比的不同之处在于，它可以重置屏障的次数，它可以在释放等待线程之后重新使用。(基于JDK1.8) 2 用法示例 CyclicBarrier默认的构造方法是CyclicBarrier（int parties），
CyclicBarrier源码解析
CyclicBarrier概述 CyclicBarrier是Java并发包中提供的一种同步工具，它允许一组线程互相等待，直到到达某个公共屏障点（common barrier point），然后继续执行。 ## 1.1 CyclicBarrier的作用和用法 ...
并发编程之 CyclicBarrier 源码分析
weixin_34032779的博客
04-30 228
前言 在之前的介绍 CountDownLatch 的文章中，CountDown 可以实现多个线程协调，在所有指定线程完成后，主线程才执行任务。 但是，CountDownLatch 有个缺陷，这点 JDK 的文档中也说了：他只能使用一次。在有些场合，似乎有些浪费，需要不停的创建 CountDownLatch 实例，JDK 在 CountDownLatch 的文档中向我们介绍了 CyclicBarr...
CyclicBarrier 深入源码解析
键盘上流淌的日子
06-27 8088
  CyclicBarrier意为“循环栅栏”，是一个可循环利用的屏障。CyclicBarrier可以使指定数量线程到达阻塞点后继续后续任务。   演示示例：   首先，新建一个线程类，用于模拟多线程环境。 package com.securitit.serialize.juc; import java.util.concurrent.CyclicBarrier; public class CyclicBarrierThread extends Thread { // CyclicBarrier实例.
【高级并发控制】：CyclicBarrier源码剖析与性能优化技巧
[【高级并发控制】：CyclicBarrier源码剖析与性能优化技巧](https://codepumpkin.com/wp-content/uploads/2017/09/cyclicBarrier.jpg) # 1. CyclicBarrier基础概念与使用方法 在并发编程的世界里，同步工具对于协调...
CyclicBarrier源码
大龙的博客
06-13 274
一、CyclicBarrier简介 CyclicBarrier 就是循环（Cyclic）使用的屏障（Barrier），它要做的事情就是让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会打开，所有被屏障拦截的线程才会继续运行。 应用示例demo如下： CyclicBarrier 还提供了一个更高级的构造函数Cyclic...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值