多线程之阶段运行———Phaser

场景：n个线程但是需要分阶段执行，并且每个阶段是符合一定条件的，以小组为单位，必须该阶段该小组的所有线程都完成了任务，才可以进行下一步任务。
可以理解为分阶段的栅栏，并且每个阶段都可以指定不同的线程

我模拟了一个学习的阶段任务小程序：

package com.hezhanghuaixiao.apipaaenger.learn;

import java.time.Period;
import java.util.Random;
import java.util.concurrent.Phaser;

/**
 * @author 何章怀晓 hezhanghuaixiao
 * @version V1.0
 * @desc
 */
public class Test0424Phaser {

  static Random random = new Random();

  static MarriagePhaser marriagePhaser = new MarriagePhaser();

  static void millisSleep(int mill) {
    try {
      Thread.sleep(mill);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  public static void main(String[] args) {
    //线程容量
    marriagePhaser.bulkRegister(7);

    //第一阶段
    new Thread(new Skill("初学java")).start();
    //第二阶段
    new Thread(new Skill("进阶学习数据结构")).start();
    new Thread(new Skill("进阶学习设计模式")).start();
    //第三阶段
    new Thread(new Skill("进阶学习算法")).start();
    new Thread(new Skill("进阶学习源码解读")).start();
    //第四阶段
    new Thread(new Skill("进阶学习三高调优")).start();
    //第五阶段
    new Thread(new Skill("成为架构师")).start();


  }


  static class MarriagePhaser extends Phaser {
    //return true==> 阶段结束
    //registeredParties 注册的线程数量

    @Override
    protected boolean onAdvance(int phase, int registeredParties) {
      switch (phase) {
        case 0:
          System.out.println("-----------菜鸟阶段");
          return false;
        case 1:
          System.out.println("-----------学习阶段");
          return false;
        case 2:
          System.out.println("-----------进阶阶段");

          return false;
        case 3:
          System.out.println("-----------生产阶段");
          return false;
        case 4:
          System.out.println("-----------上升阶段");
          return true;
        default:
          return true;
      }
    }
  }


  static class Skill implements Runnable {

    String name;

    public Skill(String name) {
      this.name = name;
    }


    public void initial() {
      millisSleep(random.nextInt(1000));
      if (name.equals("初学java")) {
        System.out.println("第一阶段" + name);
      }
      //该阶段任务完成才可以进入下一阶段
      marriagePhaser.arriveAndAwaitAdvance();
    }

    public void advanced() {
      millisSleep(random.nextInt(1000));
      if (name.equals("进阶学习数据结构") || name.equals("进阶学习设计模式")) {
        System.out.println("第二阶段" + name);
      }
      //该阶段任务完成才可以进入下一阶段
      marriagePhaser.arriveAndAwaitAdvance();
    }

    public void keepLearning() {
      millisSleep(random.nextInt(1000));
      if (name.equals("进阶学习算法") || name.equals("进阶学习源码解读")) {
        System.out.println("第三阶段" + name);
      }
      //该阶段任务完成才可以进入下一阶段
      marriagePhaser.arriveAndAwaitAdvance();
    }

    public void tuning() {
      millisSleep(random.nextInt(1000));
      if (name.equals("进阶学习三高调优")) {
        System.out.println("第四阶段" + name);
      }
      //该阶段任务完成才可以进入下一阶段
      marriagePhaser.arriveAndAwaitAdvance();
    }

    public void architect() {
      if (name.equals("成为架构师")) {
        millisSleep(random.nextInt(1000));
        System.out.println("第五阶段" + name);
        marriagePhaser.arriveAndAwaitAdvance();
      } /*else {
        //取消注册
        marriagePhaser.arriveAndDeregister();
      }*/


    }

    public void stop() {
      marriagePhaser.forceTermination();
    }

    @Override
    public void run() {
      initial();
      advanced();
      keepLearning();
      tuning();
      architect();
      stop();


    }
  }


}

这个场景比较简单，但是Phaser拓展性很强，可以根据场景拟定不同策略