JUC 工具类之 Phaser 详解

最新推荐文章于 2024-03-23 23:26:59 发布
最新推荐文章于 2024-03-23 23:26:59 发布
阅读量841 收藏 3
点赞数 1
分类专栏： Linux 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuwg1226/article/details/120257292
版权

一 概述

Phaser 是 JDK1.7 推出的，一个可重用的同步障碍，与 CyclicBarrier，CountDownLatch 功能类似，但是它支持更灵活的用法。

先简单说明这个类的作用。假设有一个大工程，可以分为多个阶段，每一个阶段有多个人参与，并且每一个阶段需要参与的所有人都完成这个阶段的事情，才可以进入下一个阶段，然后所有人又继续做下一个阶段的事，直到所有阶段都完成，当然这途中每个人都可以随时退出，整个工程也可以中途终止。

二 Phaser 的使用

例如某天陈皮约小美，小雪去他家吃饭。这个事情可以分为三个阶段，第一阶段去超市买食材，第二阶段炒菜，第三阶段吃饭，假设每一个阶段完成后才能继续下一个阶段。

首先定义阶段器类，继承 Phaser 重写 onAdvance 方法来对每一个阶段进行不同的操作。

package com.chenpi;
 ​
import java.util.concurrent.Phaser;
 ​
 /**
  * @Description 吃饭阶段器
  * @Author 陈皮
  * @Date 2021/7/4
  * @Version 1.0
  */
 public class DiningPhaser extends Phaser {
 ​
   /**
    * 每一阶段到达时，都会执行这个方法，执行完后 phase 自动加1，
    * 代表进入下一阶段
    *
    * @param phase             代表哪个阶段，从0开始
    * @param registeredParties 注册的任务
    * @return 是否终止
    */
   @Override
   protected boolean onAdvance(int phase, int registeredParties) {
     switch (phase) {
       case 0:
         System.out.println("第一阶段，买食材完成啦！总共参与人数：" + 
         registeredParties);
         return false;
       case 1:
         System.out.println("第二阶段，炒菜完成啦！总共参与人数：" + 
         registeredParties);
         return false;
       case 2:
         System.out.println("第三阶段，吃完饭啦！总共参与人数：" + 
         registeredParties);
         return false;
       default:
         return true;
     }
   }
 }

接下来定义参与的任务，编写每一个任务在每一个阶段需要干的事情。

定义陈皮的任务：

package com.chenpi;
 ​
 import java.util.concurrent.Phaser;
 ​
 /**
  * @Description 任务，代表陈皮
  * @Author 陈皮
  * @Date 2021/7/4
  * @Version 1.0
  */
 public class ChenPiTask implements Runnable {
 ​
   private Phaser phaser;
 ​
   public ChenPiTask(Phaser phaser) {
     this.phaser = phaser;
   }
 ​
   @Override
   public void run() {
     System.out.println(Thread.currentThread().getName() + 
     " 买好猪肉了...");
     // 第一阶段的事干完了，等待其他人完成才能进入下一阶段
     phaser.arriveAndAwaitAdvance();
 ​
     System.out.println(Thread.currentThread().getName() + 
     " 炒好猪肉了...");
     // 第二阶段的事干完了，等待其他人完成才能进入下一阶段
     phaser.arriveAndAwaitAdvance();
 ​
     System.out.println(Thread.currentThread().getName() + 
     " 吃饱了...");
     // 第三阶段的事干完了，等待其他人完成才能进入下一阶段
     phaser.arriveAndAwaitAdvance();
   }
 }

定义小美的任务：

 package com.chenpi;
 ​
 import java.util.concurrent.Phaser;
 ​
 /**
  * @Description 任务，代表小美
  * @Author 陈皮
  * @Date 2021/7/4
  * @Version 1.0
  */
 public class XiaoMeiTask implements Runnable {
 ​
   private Phaser phaser;
 ​
   public XiaoMeiTask(Phaser phaser) {
     this.phaser = phaser;
   }
 ​
   @Override
   public void run() {
     System.out.println(Thread.currentThread().getName() + 
     " 买好白菜了...");
     // 第一阶段的事干完了，等待其他人完成才能进入下一阶段
     phaser.arriveAndAwaitAdvance();
 ​
     System.out.println(Thread.currentThread().getName() + 
     " 炒好白菜了...");
     // 第二阶段的事干完了，等待其他人完成才能进入下一阶段
     phaser.arriveAndAwaitAdvance();
 ​
     System.out.println(Thread.currentThread().getName() + 
     " 吃饱了...");
     // 第三阶段的事干完了，等待其他人完成才能进入下一阶段
     phaser.arriveAndAwaitAdvance();
   }
 }

定义小雪的任务：

package com.chenpi;
 ​
 import java.util.concurrent.Phaser;
 ​
 /**
  * @Description 任务，代表小雪
  * @Author 陈皮
  * @Date 2021/7/4
  * @Version 1.0
  */
 public class XiaoXueTask implements Runnable {
 ​
   private Phaser phaser;
 ​
   public XiaoXueTask(Phaser phaser) {
     this.phaser = phaser;
   }
 ​
   @Override
   public void run() {
     System.out.println(Thread.currentThread().getName() + 
     " 买好鲍鱼了...");
     // 第一阶段的事干完了，等待其他人完成才能进入下一阶段
     phaser.arriveAndAwaitAdvance();
 ​
     System.out.println(Thread.currentThread().getName() + 
     " 炒好鲍鱼了...");
     // 第二阶段的事干完了，等待其他人完成才能进入下一阶段
     phaser.arriveAndAwaitAdvance();
 ​
     System.out.println(Thread.currentThread().getName() + 
     " 吃饱了...");
     // 第三阶段的事干完了，等待其他人完成才能进入下一阶段
     phaser.arriveAndAwaitAdvance();
   }
 }

最后，编写测试类，进行测试验证。

package com.chenpi;
 ​
 /**
  * @Description
  * @Author 陈皮
  * @Date 2021/7/4
  * @Version 1.0
  */
 public class ChenPiMain {
 ​
   public static void main(String[] args) {
 ​
     // 创建吃饭阶段器，注册3个任务（人）
     DiningPhaser diningPhaser = new DiningPhaser();
     diningPhaser.bulkRegister(3);
 ​
     // 三个人同时开始干活
     Thread thread1 = new Thread(new ChenPiTask(diningPhaser));
     thread1.setName("陈皮");
     thread1.start();
 ​
     Thread thread2 = new Thread(new XiaoMeiTask(diningPhaser));
     thread2.setName("小美");
     thread2.start();
 ​
     Thread thread3 = new Thread(new XiaoXueTask(diningPhaser));
     thread3.setName("小雪");
     thread3.start();
   }
 }

最后，启动服务，显示结果如下：

陈皮 买好猪肉了...
 小美 买好白菜了...
 小雪 买好鲍鱼了...
 第一阶段，买食材完成啦...
 小雪 炒好鲍鱼了...
 陈皮 炒好猪肉了...
 小美 炒好白菜了...
 第二阶段，炒菜完成啦...
 小美 吃饱了...
 陈皮 吃饱了...
 小雪 吃饱了...
 第三阶段，吃完饭啦...

二 Phaser 详解

通过以上简单例子已知道 Phaser 的作用了。其实它的作用不止这些。

可以动态调整注册任务的数量（最大注册的任务数量为 65535）。任务可以在任何时间注册（register 和 bulkRegister 方法，或者以构造方法形式注册初始任务数量），也可以在任何到达时注销注册的任务（arriveAndDeregister 方法）。

package com.chenpi;
 ​
 import java.util.concurrent.Phaser;
 ​
 /**
  * @Description 任务，代表小雪
  * @Author 陈皮
  * @Date 2021/7/4
  * @Version 1.0
  */
 public class XiaoXueTask implements Runnable {
 ​
   private Phaser phaser;
 ​
   public XiaoXueTask(Phaser phaser) {
     this.phaser = phaser;
   }
 ​
   @Override
   public void run() {
     System.out.println(Thread.currentThread().getName() + 
     " 买好鲍鱼了...");
     // 第一阶段的事干完了，等待其他人完成才能进入下一阶段
     phaser.arriveAndAwaitAdvance();
 ​
     System.out.println(Thread.currentThread().getName() + 
     " 炒好鲍鱼了...");
     // 第二阶段的事干完了，小雪有事先走了
     phaser.arriveAndDeregister();
     System.out.println(Thread.currentThread().getName() + 
     "有事先走了");
   }
 }

我们修改小雪这个任务，她干完第二阶段的事情就有事先走了，即注销任务。结果如下：

 陈皮 买好猪肉了...
 小美 买好白菜了...
 小雪 买好鲍鱼了...
 第一阶段，买食材完成啦！总共参与人数：3
 小雪 炒好鲍鱼了...
 小雪有事先走了
 陈皮 炒好猪肉了...
 小美 炒好白菜了...
 第二阶段，炒菜完成啦！总共参与人数：2
 小美 吃饱了...
 陈皮 吃饱了...
 第三阶段，吃完饭啦！总共参与人数：2

注册和注销只影响内部计数，内部没有记录具体的注册任务，所以不能查询哪个任务是否已注册。但是我们可以编写 Phaser 的子类来实现记录注册的具体任务。

package com.chenpi;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Phaser;

/**
 * @Description 吃饭阶段器
 * @Author 陈皮
 * @Date 2021/7/4
 * @Version 1.0
 */
public class DiningPhaser extends Phaser {

  // 记录注册的任务
  private List<Runnable> registeredTask = new ArrayList<>();

  public int register(Runnable task) {
    registeredTask.add(task);
    return super.register();
  }

  public List<Runnable> getRegisteredTask() {
    return registeredTask;
  }

  /**
   * 每一阶段到达时，都会执行这个方法，执行完后 phase 自动加1，代表进入下一阶段
   *
   * @param phase             代表哪个阶段，从0开始
   * @param registeredParties 注册的任务
   * @return 是否终止
   */
  @Override
  protected boolean onAdvance(int phase, int registeredParties) {
    switch (phase) {
      case 0:
        System.out.println("第一阶段，买食材完成啦！总共参与人数：" + 
        registeredParties);
        return false;
      case 1:
        System.out.println("第二阶段，炒菜完成啦！总共参与人数：" + 
        registeredParties);
        return false;
      case 2:
        System.out.println("第三阶段，吃完饭啦！总共参与人数：" + 
        registeredParties);
        return false;
      default:
        return true;
    }
  }
}

测试类中，每一个任务单独注册并记录。

package com.chenpi;

/**
 * @Description
 * @Author 陈皮
 * @Date 2021/7/4
 * @Version 1.0
 */
public class ChenPiMain {

  public static void main(String[] args) {

    // 创建吃饭阶段器，注册3个任务（人）
    DiningPhaser diningPhaser = new DiningPhaser();

    // 三个人同时开始干活
    Thread thread1 = new Thread(new ChenPiTask(diningPhaser));
    thread1.setName("陈皮");
    diningPhaser.register(thread1);
    thread1.start();

    Thread thread2 = new Thread(new XiaoMeiTask(diningPhaser));
    thread2.setName("小美");
    diningPhaser.register(thread2);
    thread2.start();

    Thread thread3 = new Thread(new XiaoXueTask(diningPhaser));
    thread3.setName("小雪");
    diningPhaser.register(thread3);
    thread3.start();

    System.out.println("注册的任务：" + 
    diningPhaser.getRegisteredTask());
  }
}

启动服务，打印了在阶段器中注册的任务。

陈皮 买好猪肉了...
注册的任务：[Thread[陈皮,5,main], Thread[小美,5,main], Thread[小雪,5,main]]
小美 买好白菜了...
小雪 买好鲍鱼了...
第一阶段，买食材完成啦！总共参与人数：3
小雪 炒好鲍鱼了...
陈皮 炒好猪肉了...
小美 炒好白菜了...
第二阶段，炒菜完成啦！总共参与人数：3
陈皮 吃饱了...
小雪 吃饱了...
小美 吃饱了...
第三阶段，吃完饭啦！总共参与人数：3

对于同步性质，像 CyclicBarrier 一样，Phaser 可以重复等待。Phaser 的 arriveAndAwaitAdvance 方法的作用类似于 CyclicBarrier 的 await 方法。

每一个 Phaser 对象都会关联一个阶段数。这个数从0开始，当所有注册的任务都到达每一个阶段的时候，这个数就递增一次。特别地，如果这个数到达 Integer.MAX_VALUE 后就会重新变回到 0。

arrive 和 arriveAndDeregister 方法记录到达，这 2 个方法不会阻塞，它们会返回已到达的阶段数。

arrive 方法表示当前任务已到达某个阶段，但是不会等待其他任务到达此阶段。arriveAndDeregister 方法表示当前任务已到达某个阶段，并且注销任务。

在每一个阶段中，当所有任务都到达的时候，onAdvance 方法会被最后一个触发阶段到达的任务执行，然后进入下一个阶段。onAdvance 方法可以控制一个 Phaser 的终止，如果我们的 Phaser 对象是继承 Phaser 的子类，可以重写 onAdvance 方法，在每一个阶段到达时这个方法就会被调用从而在每一个阶段做我们想做的事情。

package com.chenpi;

import java.util.concurrent.Phaser;

/**
 * @Description 吃饭阶段器
 * @Author 陈皮
 * @Date 2021/7/4
 * @Version 1.0
 */
public class DiningPhaser extends Phaser {

  /**
   * 每一阶段到达时，都会执行这个方法，执行完后 phase 自动加1，代表进入下一阶段
   *
   * @param phase             代表哪个阶段，从0开始
   * @param registeredParties 注册的任务
   * @return 是否终止
   */
  @Override
  protected boolean onAdvance(int phase, int registeredParties) {
    System.out.println(Thread.currentThread().getName() + 
    " 调用了onAdvance方法");
    switch (phase) {
      case 0:
        System.out.println("第一阶段，买食材完成啦！总共参与人数：" + 
        registeredParties);
        return false;
      case 1:
        System.out.println("第二阶段，炒菜完成啦！总共参与人数：" + 
        registeredParties);
        return false;
      case 2:
        System.out.println("第三阶段，吃完饭啦！总共参与人数：" + 
        registeredParties);
        return false;
      default:
        return true;
    }
  }
}

我们在 onAdvance 方法中打印当前线程，结果表明确实是最后一个触发阶段到达的任务执行 onAdvance 方法，如下：

陈皮 买好猪肉了...
小美 买好白菜了...
小雪 买好鲍鱼了...
小雪 调用了onAdvance方法
第一阶段，买食材完成啦！总共参与人数：3
小雪 炒好鲍鱼了...
陈皮 炒好猪肉了...
小美 炒好白菜了...
小美 调用了onAdvance方法
第二阶段，炒菜完成啦！总共参与人数：3
小美 吃饱了...
陈皮 吃饱了...
小雪 吃饱了...
小雪 调用了onAdvance方法
第三阶段，吃完饭啦！总共参与人数：3

phaser 可以随时被终止。当终止时，所有同步方法（例如 arriveAndAwaitAdvance ）会立即返回而不用阻塞等待，并且返回一个负数。同样地，被终止后无法再注册任务。isTerminated 方法可以判断是否已经终止。

phaser 可以在 onAdvance 方法中返回 true 来达到终止的效果。例如我们继承 Phaser 编写的子类可以重写此方法，当到达某个阶段后返回 true 来终止阶段器。

package com.chenpi;

import java.util.concurrent.Phaser;

/**
 * @Description 吃饭阶段器
 * @Author 陈皮
 * @Date 2021/7/4
 * @Version 1.0
 */
public class DiningPhaser extends Phaser {

  /**
   * 每一阶段到达时，都会执行这个方法，执行完后 phase 自动加1，代表进入下一阶段
   *
   * @param phase             代表哪个阶段，从0开始
   * @param registeredParties 注册的任务
   * @return 是否终止
   */
  @Override
  protected boolean onAdvance(int phase, int registeredParties) {
    System.out.println(Thread.currentThread().getName() + 
    " 调用了onAdvance方法");
    switch (phase) {
      case 0:
        System.out.println("第一阶段，买食材完成啦！总共参与人数：" + 
        registeredParties);
        return false;
      case 1:
        System.out.println("第二阶段，炒菜完成啦！总共参与人数：" + 
        registeredParties);
        return false;
      case 2:
        System.out.println("第三阶段，吃完饭啦！总共参与人数：" + 
        registeredParties);
        return false;
      default:
        return true;
    }
  }
}

默认的 onAdvance 方法实现是当注册的任务注销到 0 的时候返回 true，源码如下：

protected boolean onAdvance(int phase, int registeredParties) {
    return registeredParties == 0;
}

phaser 的 forceTermination 方法其实也可以强制终止阶段器。还是以上述例子，小美干完第一阶段的事情后，觉得这样等来等去太费时间了，所以终止这个阶段器。

package com.chenpi;

import java.util.concurrent.Phaser;

/**
 * @Description 任务，代表小美
 * @Author 陈皮
 * @Date 2021/7/4
 * @Version 1.0
 */
public class XiaoMeiTask implements Runnable {

  private Phaser phaser;

  public XiaoMeiTask(Phaser phaser) {
    this.phaser = phaser;
  }

  @Override
  public void run() {
    System.out.println(Thread.currentThread().getName() + 
    " 买好白菜了...");
    // 第一阶段的事干完了，等待其他人完成才能进入下一阶段
    phaser.arriveAndAwaitAdvance();

    System.out.println(Thread.currentThread().getName() + 
    " 炒好白菜了...");
    // 小美觉得这样等来等去太费时间了，所以终止这个阶段器
    phaser.forceTermination();

    System.out.println(Thread.currentThread().getName() + 
    " 吃饱了...");
    // 第三阶段的事干完了，等待其他人完成才能进入下一阶段
    phaser.arriveAndAwaitAdvance();
  }
}

再执行程序，结果第一阶段后，后续的任务执行就不再按阶段来了，结果如下：

陈皮 买好猪肉了...
小美 买好白菜了...
小雪 买好鲍鱼了...
小雪 调用了onAdvance方法
第一阶段，买食材完成啦！总共参与人数：3
小雪 炒好鲍鱼了...
小美 炒好白菜了...
小美 吃饱了...
小雪 吃饱了...
陈皮 炒好猪肉了...
陈皮 吃饱了...

Phaser 支持层次结构，可以通过构造函数 Phaser(Phaser parent) 和 Phaser(Phaser parent, int parties) 创建一个树形结构的阶段器。这样可以减轻在一个 Phaser 上注册过多的任务而导致的竞争，从而提升吞吐量，缺点是会增加单个操作的开销。

你会发现 arriveAndAwaitAdvance 方法没有抛出 InterruptedException，即使当前线程被中断，这个方法也不会返回，而是继续等待。所以如果希望在等待时可中断，或者可超时，则可以选择使用以下方法：

// 当当前阶段值等于这个方法的参数phase时，等待；不相等时候立即返回。
awaitAdvanceInterruptibly(int phase) 
// 当当前阶段值等于这个方法的参数phase时，等待；不相等时候立即返回。
// 超时会抛出超时异常
awaitAdvanceInterruptibly(int phase, long timeout, TimeUnit unit)

下面罗列一些其他常用方法：

// 获取当前到达的任务数
int getArrivedParties()

// 获取上级Phaser
Phaser getParent()
    
// 获取当前属于第几阶段
final int getPhase()
    
// 获取当前注册的任务数
int getRegisteredParties()
    
// 获取当前未到达的任务数
int getUnarrivedParties()
    
// 判断当前阶段器是否被终止
boolean isTerminated()
Big Skipper
关注
专栏目录
Java并发编程（24）—— JUC并发编程类库详解
shangjg3的博客
09-03 236
CyclicBarrier 是一个同步辅助类，用于让一组线程到达一个屏障（barrier）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。这意味着在修改操作发生时，会创建一个新的数组，并将现有的所有元素复制到新数组中，然后在新数组上进行修改。这意味着在修改操作发生时，会创建一个新的数组，然后将现有的所有元素复制到新数组中，并在新数组上进行修改。当一个线程到达交换点时，它会调用 exchange() 方法，该方法会尝试将该线程的数据与另一个线程的数据交换。
JUC线程池
最新发布
qq_63353796的博客
07-11 1316
JUC线程池
java多线程之Phaser的使用详解
08-19
主要介绍了java多线程之Phaser的使用,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
JUC之Phaser
kaikai_sk的博客
03-26 529
1. 整体 public class Phaser { //------------------------------核心参数-------------------------------------- /** * 标识内部状态 * 低0-15位表示为到达parties数 * 中16-31位表示等待的parties数 * 中32-62表示p...
Phaser详解
西瓜游侠的博客
02-13 1669
参考：Java并发编程的艺术 JDK版本：AdoptOpenJDK 11.0.10+9 1 概念 Phaser（阶段器，发音：非泽尔），是1.7引入的，用于分阶段执行任务的场景。 Phaser中定义了一些概念： phase（阶段） 类似于CyclicBarrier，Phaser也有栅栏的概念。在Phaser中，栅栏叫做phase（阶段），在任意的时间点，Phaser只处于某一个phase（阶段），初始为0，最大达到Integer.MAX_VALUE，然后重新归零。当所有的parties（参与者）都到.
java并发编程JUC并发包之Phaser
二八开的博客
07-21 284
源码解析可以看下：死磕 java同步系列之Phaser源码解析 栗子： public class MyTest { public static void main(String[] args) { Phaser phaser = new Phaser(3) {//共有3个工作线程，因此在构造函数中赋值为3 @Override protected boolean onAdvance(int phase, int registeredParties) { System.out.pr
【详解】JUC之Phaser（移相器）
xzzz2020的博客
05-10 995
目录简介简单的使用重复使用的例子动态减少API重要API注册到达不再等待机制监控子线程任务强制关闭调试API获取阶段数获取注册的数获得到达和未到达的数目总结 简介 java7中引入了一种新的可重复使用的同步屏障,称为移相器Phaser。Phaser拥有与CyclicBarrier和CountDownLatch类似的功劳. 但是这个类提供了更加灵活的应用。CountDownLatch和CyclicBarrier都是只适用于固定数量的参与者。移相器适用于可变数目的屏障，在这个意义上，可以在任何时间注册新的参与者
并发编程-JUC并发工具类应用场景详解
weixin_43874650的博客
10-13 148
ReentrantLock具体应用场景如下：1. 解决多线程竞争资源的问题，例如多个线程同时对同一个数据库进行写操作，可以使用ReentrantLock保证每次 只有一个线程能够写入。2. 实现多线程任务的顺序执行，例如在一个线程执行完某个任务后，再让另一个线程执行任务。3. 实现多线程等待/通知机制，例如在某个线程执行完某个任务后，通知其他线程继续执行任务。
并发编程之JUC并发工具类的应用场景详解
2201_75955594的博客
03-23 358
JUC并发工具类详解
掌握Java并发编程：JUC核心知识详解
- 并发性能优化：了解如何通过并发集合、工具类和线程池等技术优化并发程序的性能。 8. 实际应用场景 - 分布式锁：了解在分布式系统中如何实现锁机制，比如使用ZooKeeper或Redis等。 - 异步编程模型：了解如何在...
Phaser用法详解
.
03-27 905
Phaser用法详解 用Phaser替代CyclicBarrier和CountDownLatch Phaser相比CyclicBarrier和CountDownLatch功能更强大，包括它两的所有功能。 用Phaser替代CyclicBarrier public class PhaserTest1 { public static void main(String[] args) { Phaser phaser = new Phaser(); for (in
JUC第二十九讲：JUC工具类: Phaser详解
Jet_qi的博客
10-14 285
本文是JUC第二十九讲，JUC工具类：Phaser详解。Phaser是JDK 7新增的一个同步辅助类，它可以实现 CyclicBarrier 和CountDownLatch 类似的功能，而且它支持对任务的动态调整，并支持分层结构来达到更高的吞吐量。
并发工具类（五） Phaser类
jinggod的博客
12-04 541
前言  JDK中为了处理线程之间的同步问题，除了提供锁机制之外，还提供了几个非常有用的并发工具类：CountDownLatch、CyclicBarrier、Semphore、Exchanger、Phaser；   CountDownLatch、CyclicBarrier、Semphore、Phaser 这四个工具类提供一种并发流程的控制手段；而Exchanger工具类则提供了在线程之间交换数据的
JUC并发工具类--Phaser（阶段协同器）
qq_41139119的博客
06-18 660
JUC并发工具类--Phaser（阶段协同器）
JUC工具类Phaser
我的博客
09-19 240
简介 java7中引入了一种新的可重复使用的同步屏障,Phaser阶段器，与CyclicBarrier和CountDownLatch类似，但更强大。 CyclicBarrier解决了CountDownLatch不能重用的问题，但是仍有以下不足： 1）不能动态调整计数器值，假如线程数不足以打破barrier，就只能reset或者多加些线程，在实际运用中显然不现实 2）每次await仅消耗1个计数器值，不够灵活 Phaser就是用来解决这些问题的。Phaser将多个线程协作执行的任务划分为多个阶段，每个阶段都可
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值