Java8 Phaser 源码解析

最新推荐文章于 2025-04-25 14:11:39 发布
原创 最新推荐文章于 2025-04-25 14:11:39 发布
· 888 阅读 · 4 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Phaser

目录

一、使用

1、基本概念

2、实现CountDownLatch的效果

3、实现CyclicBarrier的效果

4、灵活调整parties

5、onAdvance

6、父子Phaser 

二、源码解析

1、定义

2、构造方法

3、register / bulkRegister 

4、arrive / arriveAndDeregister / arriveAndAwaitAdvance

5、awaitAdvance / awaitAdvanceInterruptibly / awaitAdvanceInterruptibly

6、forceTermination / isTerminated

7、getArrivedParties / getUnarrivedParties / getRegisteredParties / getPhase

       Phaser 是Java7引入一个用于控制任务阶段执行的可重复使用的同步器，包含了CountDownLatch和CyclicBarrier的功能，比他们更加灵活，更加强大，本篇博客就详细探讨该类的使用和

一、使用

1、基本概念

parties：参与线程的个数，跟CountDownLatch或者CyclicBarrier的构造方法的参数的含义是一样的，不同的是这两个只能在构造方法中指定，不能调整，而Phaser提供了调整的方法。

register / deregister : register就是通知Phaser参与等待的线程数增加了，deregister就是通知Phaser参与等待的线程数减少了，然后相应调整parties

arrive / advance：arrive跟CyclicBarrier中到达栅栏是一个意思，当所有parties个线程都arrive了，则触发advance，默认实现下如果此时parties是0，则会终止Phaser，否则将phase加1，同时将未到达线程数从0恢复至parties

phase：表示执行任务的阶段，初始值是0，每一次advance都会将该值加1，最大值是Integer.MAX_VALUE；如果Phaser被终止了，则该值为负数，此时所有的register，arrive或者await操作都会立即返回。

父子Phaser：父子Phaser一方面可以避免parties线程过多时导致cas修改state容易失败，另一方面可以基于父子Phaser实现复杂的执行任务的阶段控制。子Phaser的parties线程可以有多个，但是对于父Phaser相当于只有一个，只有子Phaser所有的parties线程都到达的时候才通知父Phaser当前子Phaser已到达，只有子Phaser所有的parties线程都被注销（deregister）了才会向父Phaser注销当前子Phaser。另外在多级父子Phaser下，子Phaser的phase永远以上一级的Phaser的phase为准，如果不一致则修改成一致，并且所有的Phaser的root属性都指向同一个祖先Phaser，调用internalAwaitAdvance方法时也是在该Phaser上调用，即所有的子Phaser都共享祖先Phaser的等待线程链表，从而实现最后一个到达的子Phaser可以唤醒其他子Phaser关联的等待线程。

2、实现CountDownLatch的效果

     测试用例如下：

 @Test
    public void test() throws Exception {
        int num=6;
        Phaser phaser=new Phaser(num);
        Random random=new Random();
        Runnable task=new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(random.nextInt(1000));
                    System.out.println(Thread.currentThread().getName()+" exit,time->"+System.currentTimeMillis());
                    //表示当前线程已到达 
                    phaser.arrive();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for(int i=0;i<num;i++){
            new Thread(task).start();
        }
        System.out.println("main thread start await,time->"+System.currentTimeMillis());
        //等待其他线程都到达
        phaser.awaitAdvance(phaser.getPhase());
        System.out.println("main thread end,time->"+System.currentTimeMillis());
    }

    @Test
    public void test2() throws Exception {
        int num=6;
        CountDownLatch countDownLatch=new CountDownLatch(num);
        Random random=new Random();
        Runnable task=new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(random.nextInt(1000));
                    System.out.println(Thread.currentThread().getName()+" exit,time->"+System.currentTimeMillis());
                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for(int i=0;i<num;i++){
            new Thread(task).start();
        }
        System.out.println("main thread start await,time->"+System.currentTimeMillis());
        countDownLatch.await();
        System.out.println("main thread end,time->"+System.currentTimeMillis());
    }

上述测试用例的输出是一样的，主线程等待5个子线程执行完任务然后退出，如下：

 

3、实现CyclicBarrier的效果

     测试用例如下：

@Test
    public void test5() throws Exception {
        int num=6;
        Phaser phaser=new Phaser(num);
        Random random=new Random();
        Runnable task=new Runnable() {
            @Override
            public void run() {
                try {
                    //到达并等待其他线程到达
                    phaser.arriveAndAwaitAdvance();
                    System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
                    Thread.sleep(random.nextInt(1000));
                    System.out.println(Thread.currentThread().getName()+" exit,time->"+System.currentTimeMillis());
                    //通知当前线程已到达
                    phaser.arrive();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for(int i=0;i<num-1;i++){
            new Thread(task).start();
        }
        System.out.println("main thread start await,time->"+System.currentTimeMillis());
        phaser.awaitAdvance(phaser.getPhase());
        System.out.println("all thread start,time->"+System.currentTimeMillis());
        phaser.awaitAdvance(phaser.getPhase());
        System.out.println("main thread end,time->"+System.currentTimeMillis());
    }

    @Test
    public void test6() throws Exception {
        int num=6;
        CyclicBarrier cyclicBarrier=new CyclicBarrier(num);
        Random random=new Random();
        Runnable task=new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                    System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
                    Thread.sleep(random.nextInt(1000));
                    System.out.println(Thread.currentThread().getName()+" exit,time->"+System.currentTimeMillis());
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };
        for(int i=0;i<num-1;i++){
            new Thread(task).start();
        }
        System.out.println("main thread start await,time->"+System.currentTimeMillis());
        cyclicBarrier.await();
        System.out.println("all thread start,time->"+System.currentTimeMillis());
        cyclicBarrier.await();
        System.out.println("main thread end,time->"+System.currentTimeMillis());
    }

 输出如下：

  

 CyclicBarrier的构造函数还支持传入一个Runnable，最后一个到达的线程会负责执行该Runnable，Phaser也可实现类似的功能，测试用例如下：

@Test
    public void test7() throws Exception {
        int num=6;
        CyclicBarrier cyclicBarrier=new CyclicBarrier(num, new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" last arrive,time->"+System.currentTimeMillis());
            }
        });
        Random random=new Random();
        Runnable task=new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                    System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
                    Thread.sleep(random.nextInt(1000));
                    System.out.println(Thread.currentThread().getName()+" exit,time->"+System.currentTimeMillis());
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };
        for(int i=0;i<num-1;i++){
            new Thread(task).start();
        }
        System.out.println("main thread start await,time->"+System.currentTimeMillis());
        cyclicBarrier.await();
        System.out.println("all thread start,time->"+System.currentTimeMillis());
        cyclicBarrier.await();
        System.out.println("main thread end,time->"+System.currentTimeMillis());
    }

    @Test
    public void test8() throws Exception {
        int num=6;
        Phaser phaser=new Phaser(num);
        Random random=new Random();
        Runnable task=new Runnable() {
            @Override
            public void run() {
                try {
                    //getUnarrivedParties等于1时，当前线程就是最后一个达到的线程
                    if(phaser.getUnarrivedParties()==1){
                        System.out.println(Thread.currentThread().getName()+" last arrive,time->"+System.currentTimeMillis());
                    }
                    phaser.arriveAndAwaitAdvance();
                    System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
                    Thread.sleep(random.nextInt(1000));
                    System.out.println(Thread.currentThread().getName()+" exit,time->"+System.currentTimeMillis());
                    if(phaser.getUnarrivedParties()==1){
                        System.out.println(Thread.currentThread().getName()+" last arrive,time->"+System.currentTimeMillis());
                    }
                    phaser.arrive();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for(int i=0;i<num;i++){
            new Thread(task).s
最低0.47元/天 解锁文章
Java线程之Phaser
华丽的痘痘
04-23 1万+
Phaser是一个灵活的线程同步工具，他包含了CyclicBarrier和CountDownLatch的相关功能        首先，来看一下如何用Phaser替代CountDownLatch。对于CountDownLatch而言，有2个重要的方法，一个是await()方法，可以使线程进入等待状态，在Phaser中，与之对应的方法是awaitAdvance(int n)。CountDownL
phaser java_死磕 java同步系列之Phaser源码解析
weixin_30193269的博客
02-19 220
问题(1)Phaser是什么？(2)Phaser具有哪些特性？(3)Phaser相对于CyclicBarrier和CountDownLatch的优势？简介Phaser，翻译为阶段，它适用于这样一种场景，一个大任务可以分为多个阶段完成，且每个阶段的任务可以多个线程并发执行，但是必须上一个阶段的任务都完成了才可以执行下一个阶段的任务。这种场景虽然使用CyclicBarrier或者CountryDown...
掌握 Java 并发包中的 Phaser 同步工具
最新发布
潜意识Java的博客
04-25 563
Phaser（阶段器）是一个可复用的同步工具，它允许一组线程在执行过程中进行分阶段同步。每个阶段都有唯一的编号（从 0 开始），线程可以在阶段末尾等待其他线程，直到所有线程都到达该阶段后，Phaser才会推进到下一阶段。其核心逻辑基于register()（注册线程）、arrive()（线程到达）和（等待阶段推进）等方法实现。Phaser作为 Java 并发包中的高级同步工具，以其灵活的阶段控制和动态线程管理能力，为复杂并发场景提供了高效的解决方案。通过掌握Phaser。
源码分析-Phaser
千念飞羽的专栏
02-23 1843
Phaser 使用方法 这是一个比CyclicBarrier更加灵活的同步屏障。从灵活性的角度来说Phaser>CyclicBarrier>CountDownLatch。 Phaser中有一个概念叫阶段（用phaser）表示，这个只能增长不能减小。每个阶段可以有不同数量的分阶段（party，不知道怎么翻译了。先用这个）。当有足够数量的分阶段到达的时候就进入下一个阶段。 获得Phaser
Phaser实现源码剖析
PunC的专栏
07-19 1740
在这里首先说明一下，由于Phaser在4.3代码里是存在，但并没有被开放出来供使用，但已经被本人大致研究了，因此也一并进行剖析。     Phaser是一个可以重复利用的同步栅栏，功能上与CyclicBarrier和CountDownLatch相似，不过提供更加灵活的用法。也就是说，Phaser的同步模型与它们差不多。一般运用的场景是一组线程希望同时到达某个执行点后（先到达的会被阻塞），执行一个
深读源码-java同步系列之Phaser源码解析
每天叫醒自己的不是闹铃 是娟 是梦 是理想。
05-26 319
问题 （1）Phaser是什么？ （2）Phaser具有哪些特性？ （3）Phaser相对于CyclicBarrier和CountDownLatch的优势？ 简介 Phaser，翻译为阶段，它适用于这样一种场景，一个大任务可以分为多个阶段完成，且每个阶段的任务可以多个线程并发执行，但是必须上一个阶段的任务都完成了才可以执行下一个阶段的任务。 这种场景虽然使用CyclicBarrier或者CountryDownLatch也可以实现，但是要复杂的多。首先，具体需要多少个阶段是可能会变的，其次，每个阶
Java8 ForkJoinPool（一） 源码解析
菜鸟进阶之路
04-28 2891
目录 一、ForkJoinWorkerThread 1、定义 2、run /getPoolIndex 二、InnocuousForkJoinWorkerThread 三、ForkJoinWorkerThreadFactory 四、WorkQueue 1、定义 2、push /pop /poll /pollAt /peek /tryUnpush 3、runTask 4...
Java并发编程源码解析与实践技巧
资源摘要信息:"《Java并发编程的艺术》是一本专门讲解Java并发编程技术的书籍，作者深入浅出...以上内容基于提供的文件信息，详细阐述了《Java并发编程的艺术》书籍的内容和重要性，以及可能包含的源码文件的相关信息。
Java并发编程实战源码解析
该包由JSR 166小组负责开发，引入了诸如ExecutorService、ReentrantLock、Semaphore、CyclicBarrier和Phaser等并发工具。 3. “Java 7 Concurrency Cookbook”内容概览： “Java 7 Concurrency Cookbook”是一本...
Java并发手册：Java 7 Concurrency Cookbook源码解析
5. **同步器工具**：讲解如何使用CountDownLatch、CyclicBarrier、Phaser等同步辅助工具。 6. **线程的高级特性**：涵盖线程的中断、线程状态、线程优先级等高级特性及其应用。 #### 实践性 本书不仅理论讲解到位...
Phaser案例及源码分析
qq_65056252的博客
01-22 1829
Phaser的使用及其源码分析
死磕 java同步系列之Phaser源码解析
weixin_30555515的博客
10-01 254
问题 （1）Phaser是什么？ （2）Phaser具有哪些特性？ （3）Phaser相对于CyclicBarrier和CountDownLatch的优势？ 简介 Phaser，翻译为阶段，它适用于这样一种场景，一个大任务可以分为多个阶段完成，且每个阶段的任务可以多个线程并发执行，但是必须上一个阶段的任务都完成了才可以执行下一个阶段的任务。 这种场景虽然使用CyclicBarrier或者...
Phaser源码讲解
不愿言弃-念何的博客
10-03 699
如果当前操作不是首次注册，那么直接在当前phaser上更新注册parties数如果是首次注册，并且当前phaser没有父节点，说明是root节点注册，直接更新phase如果当前操作是首次注册，并且当前phaser由父节点，则注册操作交由父节点，并更新当phaser的phase上面说过，子Phaser的phase在没有被真正使用之前，允许滞后于它的root节点。在终止时，所有同步方法立刻返回一个负值。如果当前phaser有父节点，并且当前phaser上没有已注册的party，那么就会交给父节点注册。
【Java并发编程实战】—–“J.U.C”：Phaser
chenssy 的技术博客
11-23 3764
Phaser由java7中推出，是Java SE 7中新增的一个使用同步工具，在功能上面它与CyclicBarrier、CountDownLatch有些重叠，但是它提供了更加灵活、强大的用法。CyclicBarrier，允许一组线程互相等待，直到到达某个公共屏障点。它提供的await()可以实现让所有参与者在临界点到来之前一直处于等待状态。CountDownLatch，在完成一组正在其他线程中执行
Java 并发编程 （三）Phaser
m0_43582028的博客
01-04 658
CyclicBarrier 解决了 CountDownLatch的缺点，但是其本身也仍然具备一定的缺陷，比如不可以动态添加parties 调用一次await 仅占用1个partiestry {} } }使用 arriveAndAwaitAdvance方法再遇到计数不足时会导致进程被阻塞 可以使用 arriveAndDeregister 在线程结束时使partie减一。只需改动下 testB方法即可验证try {} }
【Java8源码分析】集合框架-HashMap
linxd
05-10 2545
一、HashMap的存储结构总共有两种存储类// 1. 哈希冲突时采用链表法的类，一个哈希桶多于8个元素改为TreeNode static class Node<K,V> implements Map.Entry<K,V> // 2. 哈希冲突时采用红黑树存储的类，一个哈希桶少于8个元素改为Node static final class TreeNode<K,V> extends LinkedHas
java8新特性源码解析
xiaomin的博客
02-01 1295
1 Lambda表达式与Functional接口 Lambda表达式（也称为闭包）是整个Java 8发行版中最受期待的在Java语言层面上的改变，Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中），或者把代码看成数据：函数式程序员对这一概念非常熟悉。在JVM平台上的很多语言（Groovy，Scala，……）从一开始就有Lambda，但是Java程序员不得不使用毫无新意的匿名类来
【Java源码分析】Java8的String源码分析
长路漫漫的歇脚处
07-03 7174
学习Java8的String源码以及相关问题的总结 1. String的定义 2. 字段属性 3. 构造函数 4. 长度和是否为空函数 5. charAt、codePointAt类型函数 6. getChar、getBytes类型函数 7. equal类函数(是否相等) 8. regionMatchs()方法 9. compareTo类函数和CaseInsensitiveComparator静态内部类 10. startWith、endWith类函数 11. ha
Java 多线程之 Phaser（多阶段任务/同步辅助类）
QIFU的专栏
12-01 1441
Phaser 也是Java并发编程中的一种同步辅助工具，用于线程之间的协调和同步。它提供了比和更灵活和强大的功能，可以用于更复杂的多线程协作场景。Phaser的主要用途是将多个线程分为多个阶段，并在每个阶段进行同步。每个线程可以独立运行，但在特定的阶段需要等待其他线程到达屏障点。Phaser可以动态地适应线程的注册和注销，可以处理可变数量的参与者。多阶段任务：Phaser 可以用于将一个任务分解为多个阶段，每个阶段由多个线程并行执行，等待所有线程完成当前阶段后再进入下一个阶段。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值