并发工具CyclicBarrier源码分析及应用

 

本文首发于微信公众号【猿灯塔】，转载引用请说明出处

今天呢！灯塔君跟大家讲：

并发工具CyclicBarrier源码分析及应用

一.CyclicBarrier简介

1.简介

CyclicBarrier是一个同步的辅助类，允许一组线程相互之间等待，达到一个共同点，再继续执行。 CyclicBarrier（循环屏障） 直译为可循环使用（Cyclic）的屏障（Barrier）。它可以让一组线程到 达一个屏障（同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才 会继续工作。

JDK中的描述：

A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point. CyclicBarriers are useful in programs involving a fixed sized party of threads that must occasionally wait for each other. The barrier is called cyclic because it can be re-used after the waiting threads are released. CyclicBarrier是一个同步辅助类，它允许一组线程相互等待直到所有线程都到达一个公共的屏障点。 在程序中有固定数量的线程，这些线程有时候必须等待彼此，这种情况下，使用CyclicBarrier很有帮 助。这个屏障之所以用循环修饰，是因为在所有的线程释放彼此之后，这个屏障是可以重新使用的

2.运行机制

二.CyclicBarrier结构图

三.CyclicBarrier方法说明

1.CyclicBarrier(parties)

初始化相互等待的线程数量的构造方法

2.CyclicBarrier(parties,RunnablebarrierAction)

初始化相互等待的线程数量的构造方法以及屏障线程的构造方法 屏障线程的运行时机：等待的线程数量 = parties，CyclicBarrier打开屏障之前 举例：在分组计算中，每个线程负责一部分计算，最终这些线程计算结束之后，交由屏障线程进行汇总计算

3、getParties（） 

获取CyclicBarrier打开屏障的线程数量，也成为方数

4、getNumberWaiting() 

获取真在CyclicBarrier上等待的线程数量

5、await()

在CyclicBarrier上进行阻塞等待，直到发生以下情形之一：

a.在CyclicBarrier上等待的线程数量达到parties，则所有线程被释放，继续执行。

b.当前线程被中断，则抛出InterruptedException异常，并停止等待，继续执行。

c.其他等待的线程被中断，则当前线程抛出BrokenBarrierException异常，并停止等待，继续执行。

d.其他等待的线程超时，则当前线程抛出BrokenBarrierException异常，并停止等待，继续执行。

e.其他线程调用CyclicBarrier.reset()方法，则当前线程抛出BrokenBarrierException异常，并 停止等待，继续执行。

6、await(timeout,TimeUnit)

在CyclicBarrier上进行限时的阻塞等待，直到发生以下情形之一：

a.在CyclicBarrier上等待的线程数量达到parties，则所有线程被释放，继续执行。

b.当前线程被中断，则抛出InterruptedException异常，并停止等待，继续执行。

c.当前线程等待超时，则抛出TimeoutException异常，并停止等待，继续执行。

d.其他等待的线程被中断，则当前线程抛出BrokenBarrierException异常，并停止等待，继续执行。

e.其他等待的线程超时，则当前线程抛出BrokenBarrierException异常，并停止等待，继续执行。

f.其他线程调用CyclicBarrier.reset()方法，则当前线程抛出BrokenBarrierException异常，并 停止等待，继续执行。

7、isBroken

获取是否破损标志位broken的值，此值有以下几种情况：

a.CyclicBarrier初始化时，broken=false，表示屏障未破损。

b.如果正在等待的线程被中断，则broken=true，表示屏障破损。

c.如果正在等待的线程超时，则broken=true，表示屏障破损。

d.如果有线程调用CyclicBarrier.reset()方法，则broken=false，表示屏障回到未破损状态。

8、reset 

使得CyclicBarrier回归初始状态，直观来看它做了两件事： a.如果有正在等待的线程，则会抛出BrokenBarrierException异常，且这些线程停止等待，继续执行。 b.将是否破损标志位broken置为false。

四.源码分析

首先看一下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();

/**实际中仍在等待的线程数，每当有一个线程到达屏障点，

count值就会减一；当一次新的运算开始后，

count的值被重置为parties*/

private int count;

其中，Generation是CyclicBarrier的一个静态内部类

它只有一个boolean类型的属性，具体代码如下：

private static class Generation { Generation() {} // prevent access constructor creation boolean broken; // initially false }

当使用构造方法创建CyclicBarrier实例的时候

就是给上面这些属性赋值

//创建一个CyclicBarrier实例，parties指定参与相互等待的线程数，

//barrierAction指定当所有线程到达屏障点之后，

首先执行的操作，该操作由最后一个进入屏障点线程执行.

public CyclicBarrier(int parties,

Runnable barrierAction) {

if (parties <= 0) throw new IllegalArgumentException();

this.parties = parties; this.count = parties; this.barrierCommand = barrierAction; }

//创建一个CyclicBarrier实例，parties指定

参与相互等待的线程数

public CyclicBarrier(int parties) { this(parties, null); }

CyclicBarrier.await方法调用CyclicBarrier.dowait()

每次调用await()都会使计数器-1，当减少到0 时就会

唤醒所有的线程 ，当调用await()方法时，当前线程已经

到达屏障点，当前线程阻塞进入休眠状态

//该方法被调用时表示当前线程已经到达屏障点，

当前线程阻塞进入休眠状态

//直到所有线程都到达屏障点，当前线程才会被唤醒 public int await() throws InterruptedException, BrokenBarrierException { try {return dowait(false, 0L); } catch (TimeoutException toe) { throw new Error(toe); // cannot happen } }

当前线程已经到达屏障点，当前线程阻塞进入休眠状态

//该方法被调用时表示当前线程已经到达屏障点.当前   线程阻塞进入休眠状态

//在timeout指定的超时时间内，等待其他参与线程

到达屏障点

//如果超出指定的等待时间则抛TimeoutException

异常，如果该时间小于等于零，则此方法根本不会等待

public int await(long timeout, TimeUnit unit)

throws InterruptedException, BrokenBarrierException,

TimeoutException { return dowait(true, unit.toNanos(timeout)); }

dowait（）方法

private int dowait(boolean timed, long nanos)

throws InterruptedException, BrokenBarrierException, TimeoutException

{ //使用独占资源锁控制多线程并发进入这段代码

final ReentrantLock lock = this.lock;

//独占锁控制线程并发访问

lock.lock();

try {final Generation g = generation;

if (g.broken) throw new BrokenBarrierException();

//检查当前线程是否被中断

if (Thread.interrupted()) {

//如果当前线程被中断会做以下三件事

//1.打翻当前栅栏

//2.唤醒拦截的所有线程

//3.抛出中断异常

breakBarrier();

throw new InterruptedException(); }

//每调用一次await()方法，计数器就减一

int index = --count;

//计数器的值减为0则需唤醒所有线程并转换到下一代

if (index == 0) { // tripped boolean ranAction = false;

try {

//如果在创建CyclicBarrier实例时设置了barrierAction，则先执行 barrierAction

final Runnable command = barrierCommand;

if (command != null)

command.run();

ranAction = true;

//当所有参与的线程都到达屏障点，为唤醒所有处于

休眠状态的线程做准备工作

//需要注意的是，唤醒所有阻塞线程不是在这里 nextGeneration();

return 0;

} finally {

//确保在任务未成功执行时能将所有线程唤醒

if (!ranAction)

breakBarrier();

}

}

// loop until tripped, broken,

interrupted, or timed out

//如果计数器不为0则执行此循环

for (;;)

{ try {

//根据传入的参数来决定是定时等待还是非定时等待

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(); } }

//如果线程因为打翻栅栏操作而被唤醒则抛出异常

if (g.broken) throw new BrokenBarrierException();

if (g != generation) return index;

//如果线程因为时间到了而被唤醒则打翻栅栏

并抛出异常

if (timed && nanos <= 0L) {

breakBarrier();

throw new TimeoutException(); }

}

}

finally { lock.unlock(); } }

每次调用await方法都会使内部的计数器临时变量-1

当减少到0时，就会调用nextGeneration方法

private void nextGeneration() {

// signal completion of last generation trip.signalAll();

// set up next generation

count = parties; generation = new Generation(); }

在这里唤醒所有阻塞的线程 

提醒：在声明CyclicBarrier的时候还可以传一个Runnable的实现类，当计数器减少到0时，

会执行该 实现类 到这里CyclicBarrier的

实现原理基本已经都清楚了下面来深入源码分析

一下线程阻塞代码 trip.await()和线程唤醒trip.signalAll()的实现。

//await()是AQS内部类ConditionObject中的方法 public final void await() throws InterruptedException {

//如果线程中断抛异常

if (Thread.interrupted())

throw new InterruptedException();

//新建Node节点，并将新节点加入到Condition

等待队列中

//Condition等待队列是AQS内部类

ConditionObject实现的，ConditionObject

有两个属性，

分别是firstWaiter和lastWaiter

都是Node类型

//firstWaiter和lastWaiter分别用于代表Condition等待队列的头结点和尾节点 Node node = addConditionWaiter();

//释放独占锁，让其它线程可以获取到dowait()

方法中的独占锁

int savedState = fullyRelease(node);

int interruptMode = 0;

//检测此节点是否在资源等待队列(AQS同步队列)中， //如果不在，说明此线程还没有竞争资源锁的权利，

此线程继续阻塞，直到检测到此节点在 资源等待队列上(AQS同步队列)中

//这里出现了两个等待队列，分别是Condition等待

队列和AQS资源锁等待队列(或者说是 同步队列) //Condition等待队列是等待被唤醒的线程队列

AQS资源锁等待队列是等待获取资源锁 的队列

while (!isOnSyncQueue(node))

{

//阻塞当前线程，当前线程进入休眠状态，可以看到

这里使用LockSupport.park阻 塞当前线程 LockSupport.park(this);

if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) break; }

if (acquireQueued(node, savedState) && interruptMode != THROW_IE) interruptMode

= REINTERRUPT;

if (node.nextWaiter != null)

// clean up if cancelled unlinkCancelledWaiters();

if (interruptMode != 0) reportInterruptAfterWait(interruptMode); }

//addConditionWaiter()是AQS内部类ConditionObject中的方法

private Node addConditionWaiter()

{ Node t = lastWaiter;

// 将condition等待队列中，节点状态不是

CONDITION的节点，从condition等待队列中移除

if (t != null && t.waitStatus != Node.CONDITION)

{ unlinkCancelledWaiters();

t = lastWaiter; }

//以下操作是用此线程构造一个节点，并将之加入到condition等待队列尾部

Node node = new Node(Thread.currentThread(), Node.CONDITION);

if (t == null)

firstWaiter = node;

else

t.nextWaiter = node;

lastWaiter = node; return node; }

//signalAll是AQS内部类ConditionObject中

的方法

public final void signalAll() {

if (!isHeldExclusively())

throw new IllegalMonitorStateException(); //Condition等待队列的头结点

Node first = firstWaiter;

if (first != null) doSignalAll(first); }

private void doSignalAll(Node first) { lastWaiter = firstWaiter = null; do {Node next = first.nextWaiter; first.nextWaiter = null;

//将Condition等待队列中的Node节点按之前顺序

都转移到了AQS同步队列中 transferForSignal(first);

first = next;

} while (first != null); }

final boolean transferForSignal

(Node node) {

if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))

return false;

//这里将Condition等待队列中的Node节点插入到

AQS同步队列的尾部 Node p = enq(node);

int ws = p.waitStatus; if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL)) LockSupport.unpark(node.thread); return true; }

//ReentrantLock#unlock()方法

public void unlock() {

//Sync是ReentrantLock的内部类，继承自AbstractQueuedSynchronizer，

它是 ReentrantLock中公平锁和非公平锁的基础实现 sync.release(1); }

public final boolean release(int arg) {

//释放锁

if (tryRelease(arg)) {

//AQS同步队列头结点

Node h = head; if (h != null && h.waitStatus != 0)

//唤醒节点中的线程

unparkSuccessor(h); return true; }

return false; }

private void unparkSuccessor(Node node)

{ int ws = node.waitStatus;

if (ws < 0) compareAndSetWaitStatus(node, ws, 0);

Node s = node.next;

if (s == null || s.waitStatus > 0)

{ s = null; for (Node t = tail;

t != null && t != node; t = t.prev)

if (t.waitStatus <= 0) s = t; }

if (s != null) //唤醒阻塞线程 LockSupport.unpark(s.thread); }

365天干货不断,可以微信搜索「 猿灯塔」第一时间阅读，回复【资料】【面试】【简历】有我准备的一线大厂面试资料和简历模板