Java并发编程中的CyclicBarrier使用解析

 更新时间:2023年12月20日 09:38:46   作者:Brain_L  
这篇文章主要介绍了Java并发编程中的CyclicBarrier使用解析,CyclicBarrier从字面意思上来看,循环栅栏,这篇文章就来分析下是到底是如何实现循环和栅栏的,需要的朋友可以参考下

Java的CyclicBarrier

CyclicBarrier从字面意思上来看,循环栅栏,这篇文章就来分析下是到底是如何实现循环和栅栏的。

属性

private final ReentrantLock lock = new ReentrantLock();
/** Condition to wait on until tripped */
private final Condition trip = lock.newCondition();
/** The number of parties */
private final int parties;
/* The command to run when tripped */
private final Runnable barrierCommand;
/** The current generation */
private Generation generation = new Generation();
private int count;
private static class Generation {
    boolean broken = false;
}
public CyclicBarrier(int parties, Runnable barrierAction) {
    if (parties <= 0) throw new IllegalArgumentException();
    this.parties = parties;
    this.count = parties;
    this.barrierCommand = barrierAction;
}
public CyclicBarrier(int parties) {
    this(parties, null);
}

CyclicBarrier有两个构造器,一个接收资源总数,一个接收资源总数和回调线程。回调线程在哪使用,后面再看。

因为CyclicBarrier是可以重复使用的,那么就需要有一个变量标识所有的线程是属于同一个过程的。CyclicBarrier定义了Generation,代际,其中只有一个变量broken,表示当前代际是否被破坏,默认为false。

await

CyclicBarrier最重要的方法就是await。

public int await() throws InterruptedException, BrokenBarrierException {
    try {
        return dowait(false, 0L);
    } catch (TimeoutException toe) {
        throw new Error(toe); // cannot happen
    }
}
private int dowait(boolean timed, long nanos)
        throws InterruptedException, BrokenBarrierException,
               TimeoutException {
        final ReentrantLock lock = this.lock;
        lock.lock();//1、获取锁
        try {
            final Generation g = generation;
            //2、是否已更新换代
            if (g.broken)
                throw new BrokenBarrierException();
            //3、是否被中断
            if (Thread.interrupted()) {
                //4、跳出栅栏
                breakBarrier();
                throw new InterruptedException();
            }
            //5、当前线程到达栅栏,计数减1
            int index = --count;
            //6、所有线程都到达了栅栏
            if (index == 0) {  // tripped
                boolean ranAction = false;
                try {
                    //7、获取回调线程
                    final Runnable command = barrierCommand;
                    if (command != null)
                        //8、如果生成时传入了回调线程,启动回调线程
                        command.run();
                    ranAction = true;
                    //9、重置,开始下一代
                    nextGeneration();
                    return 0;
                } finally {
                    //10、如果ranAction为false,说明回调线程执行出错了
                    if (!ranAction)
                        //11、跳出栅栏
                        breakBarrier();
                }
            }
            // loop until tripped, broken, interrupted, or timed out
            for (;;) {
                try {
                    if (!timed)
                        //12、如果不需要超时等待,则立即调用Condition的await
                        trip.await();
                    else if (nanos > 0L)
                        //13、如果需要超时等待
                        nanos = trip.awaitNanos(nanos);
                } catch (InterruptedException ie) {//14、如果等待时被中断了
                    //15、如果等待前和现在处于同一代,并且没有被跳出过
                    if (g == generation && ! g.broken) {
                        //16、跳出栅栏
                        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.
                        //17、不属于本代的线程,补中断
                        Thread.currentThread().interrupt();
                    }
                }
                //18、被其他线程唤醒,此时本代已经被破坏
                if (g.broken)
                    throw new BrokenBarrierException();
                //19、不属于本代,又不是因为别的线程中断
                if (g != generation)
                    return index;
                //20、如果等待超时,跳出栅栏
                if (timed && nanos <= 0L) {
                    breakBarrier();
                    throw new TimeoutException();
                }
            }
        } finally {
            lock.unlock();
        }
    }
private void breakBarrier() {
        //1、更新换代
        generation.broken = true;
        //2、重置计数
        count = parties;
        //3、唤醒所有在等待通过栅栏的线程
        trip.signalAll();
}
private void nextGeneration() {
        // signal completion of last generation
        //1、唤醒所有在等待通过栅栏的线程
        trip.signalAll();
        // set up next generation
        //2、重置计数
        count = parties;
        //3、重新生成代际,此时broken为false
        generation = new Generation();
}

当线程调用了await时,认为该线程已经到达了栅栏,计数减1,并进入阻塞等待。当最后一个线程到达栅栏时,如果生成时传入了回调线程,此时执行,然后唤醒所有等待的线程,并更新换代。这是正常的流程。

线程在等待时会被四种情况唤醒:

  • 正常流程,最后一个线程达到栅栏后发起的唤醒
  • 本线程在等待时被中断了
  • 别的线程发生了中断,触发代际破坏,唤醒了等待中的线程
  • 本线程等待超时了

如果代际被破坏了,会抛出BrokenBarrierException。

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

线程也可以调用reset来重置代际,但是这也会导致已经在等待的线程抛出BrokenBarrierException。

对比CountDownLatch

CountDownLatch只能使用一次,而CyclicBarrier支持循环更新代际,多次调用和重置,同时它还提供了所有线程到达栅栏时执行回调的功能。

CountDownLatch底层是共享获取,CyclicBarrier是独占获取(通过调用ReentrantLock)。

到此这篇关于Java并发编程中的CyclicBarrier使用解析的文章就介绍到这了,更多相关Java的CyclicBarrier内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • java使用数组和链表实现队列示例

    java使用数组和链表实现队列示例

    队列是一种特殊的线性表,它只允许在表的前端(front)进行删除操作,只允许在表的后端(rear)进行插入操作,下面介绍一下java使用数组和链表实现队列的示例
    2014-01-01
  • Java中map内部存储方式解析

    Java中map内部存储方式解析

    这篇文章主要介绍了Java中map内部存储方式解析的相关内容,涉及其实现方式,以及对存储方式作了简单的比较,具有一定参考价值,需要的朋友可了解下。
    2017-10-10
  • java线程中synchronized和Lock区别及介绍

    java线程中synchronized和Lock区别及介绍

    这篇文章主要为大家介绍了java线程中synchronized和Lock区别及介绍,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-06-06
  • Java:

    Java:"失效"的private修饰符

    本文主要介绍Java 失效的private修饰符,这里整理了相关资料说明private 修饰符的作用,如何使用并与C++ 做比较,有兴趣的小伙伴可以参考下
    2016-08-08
  • Java设计模式之代理模式详细解读

    Java设计模式之代理模式详细解读

    这篇文章主要介绍了Java设计模式的代理模式,文中有非常详细的代码示例,对正在学习Java设计模式的小伙伴有很大的帮助,感兴趣的小伙伴可以参考一下
    2021-08-08
  • Java如何防止JS脚本注入代码实例

    Java如何防止JS脚本注入代码实例

    这篇文章主要介绍了Java如何防止JS脚本注入代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-09-09
  • SpringBoot整合Ip2region获取IP地址和定位的详细过程

    SpringBoot整合Ip2region获取IP地址和定位的详细过程

    ip2region v2.0 - 是一个离线IP地址定位库和IP定位数据管理框架,10微秒级别的查询效率,提供了众多主流编程语言的 xdb 数据生成和查询客户端实现 ,这篇文章主要介绍了SpringBoot整合Ip2region获取IP地址和定位,需要的朋友可以参考下
    2023-06-06
  • java多线程模拟实现售票功能

    java多线程模拟实现售票功能

    这篇文章主要为大家详细介绍了java多线程模拟实现售票功能,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2021-08-08
  • java md5工具类分享

    java md5工具类分享

    这篇文章主要介绍了java的md5工具类,需要的朋友可以参考下
    2014-02-02
  • Springboot如何使用OSHI获取和操作系统和硬件信息

    Springboot如何使用OSHI获取和操作系统和硬件信息

    这篇文章主要介绍了Springboot如何使用OSHI获取和操作系统和硬件信息问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2023-10-10

最新评论