Java多线程之----Phaser

本文主要是介绍Java多线程之----Phaser，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

    Phaser类的功能和CyclicBarrier、CountDownLatch的有很多类似的地方，例如线程互相等待，等待某个线程完成再进行其他任务，这在Phaser都可以实现，而Phaser却更加的灵活，因为它可以动态的注册线程数量，取消注册数量，这可以给我们带来更多的控制。

    Phaser有几个重要的方法：

        1.arrive:该方法简单的说就是记录到达的线程数，有点像CountDownLatch的countDown，该方法调用后不会等待其他线程

        2.arriveAwaitAdvance:该方法和arrive一样，但是该方法调用会等待其他未到达的线程

        3.arriveAndDeregister:该方法和arrive一样，但是该方法调用后会减少注册的数量

        4.register:该方法可以动态的注册一个线程数量

    

    有如下情景：学生进行考试，需要全部考生都考完之后才可以离场，代码如下：

public class PhaserTest1 {public static void main(String[] args) {Phaser phaser = new Phaser(5);for (int i = 0; i < 5; i++) {new Thread(new Student(phaser, "考生" + i)).start();}}public static class Student implements Runnable {private Phaser phaser;private String name;public Student(Phaser phaser, String name) {this.phaser = phaser;this.name = name;}@Overridepublic void run() {try {System.out.println(name + "进入考场，开始考试....");Thread.sleep((int) (Math.random() * 10) * 1000);System.out.println(name + "考完,等待其他考生考完后离场");phaser.arriveAndAwaitAdvance();// 使用该方法会阻塞,直到所有线程都到达这个点程序才继续运行System.out.println(name + "考生离场....");} catch (InterruptedException e) {e.printStackTrace();}}}}

    结果如下

//考生1进入考场，开始考试....
//考生3进入考场，开始考试....
//考生0进入考场，开始考试....
//考生2进入考场，开始考试....
//考生4进入考场，开始考试....
//考生1考完,等待其他考生考完后离场
//考生0考完,等待其他考生考完后离场
//考生4考完,等待其他考生考完后离场
//考生3考完,等待其他考生考完后离场
//考生2考完,等待其他考生考完后离场
//考生4考生离场....
//考生0考生离场....
//考生2考生离场....
//考生3考生离场....
//考生1考生离场....

    Phaser初始化的时候，传入了参数5，则表示当调用了arriveAndAwaitAdvance方法之后，该线程会阻塞直到5个线程都到达这里才会继续执行后面的代码

    如果初始化的时候，传入的是6，那么这5个线程就会一直等待

    如果将arriveAndAwaitAdvance改成arrive，那么结果是：

//考生0进入考场，开始考试....
//考生1进入考场，开始考试....
//考生3进入考场，开始考试....
//考生4进入考场，开始考试....
//考生2进入考场，开始考试....
//考生0考完,等待其他考生考完后离场
//考生0考生离场....
//考生1考完,等待其他考生考完后离场
//考生1考生离场....
//考生3考完,等待其他考生考完后离场
//考生3考生离场....
//考生4考完,等待其他考生考完后离场
//考生4考生离场....
//考生2考完,等待其他考生考完后离场
//考生2考生离场....

    当执行完arrive之后，并不会等待，而是正常执行

    接下来看下arriveAndDeregister方法，修改main方法中的代码，如下

	public static void main(String[] args) {Phaser phaser = new Phaser(6);// 初始化注册线程数量为6for (int i = 0; i < 5; i++) {// 只有5个线程，如果没有其他操作，那么线程会一直阻塞new Thread(new Student(phaser, "考生" + i)).start();}Scanner scanner = new Scanner(System.in);scanner.nextLine();phaser.arriveAndDeregister();//调用该方法，减少注册是数量，即6->5，那么原有的5个线程已经满足条件，所有线程继续执行System.out.println("考试结束");}

    结果如下

考生0进入考场，开始考试....
考生2进入考场，开始考试....
考生4进入考场，开始考试....
考生1进入考场，开始考试....
考生3进入考场，开始考试....
考生0考完,等待其他考生考完后离场
考生4考完,等待其他考生考完后离场
考生2考完,等待其他考生考完后离场
考生3考完,等待其他考生考完后离场
考生1考完,等待其他考生考完后离场考试结束
考生2考生离场....
考生4考生离场....
考生0考生离场....
考生1考生离场....
考生3考生离场....

    在我按下回车时候，程序才继续执行

    接下来再说下register方法

    

public class PhaserTest2 {public static void main(String[] args) {Phaser phaser = new Phaser(1);// 注册了一个线程for (int i = 0; i < 5; i++) {new Thread(new Student(phaser, "考生" + i)).start();}Scanner scanner = new Scanner(System.in);scanner.nextLine();phaser.arriveAndDeregister();System.out.println("考试结束");}public static class Student implements Runnable {private Phaser phaser;private String name;public Student(Phaser phaser, String name) {this.phaser = phaser;this.name = name;}@Overridepublic void run() {try {phaser.register();// 每个子线程都会注册一次，所有最后一共有6个注册线程System.out.println(name + "进入考场，开始考试....");Thread.sleep((int) (Math.random() * 10) * 1000);System.out.println(name + "考完,等待其他考生考完后离场");phaser.arriveAndAwaitAdvance();// 使用该方法会阻塞,直到所有线程都到达这个点程序才继续运行System.out.println(name + "考生离场....");} catch (InterruptedException e) {e.printStackTrace();}}}
}

    一开始注册了1个线程，后来每个子线程都注册了一次，效果和上个例子的是一样的

    Phaser还有一个用法，就是重写onAdvance方法。当所有线程都到达了(即使用了arrive、arriveAndAwaitAdvance、arriveAndDeregister方法)，那么就会调用onAdvance方法一次。

    该方法有两个参数，一个参数是代表当前是第几个阶段(所有线程到达一次为一个阶段，从0开始)

    如果考生需要考语数英3门考试，这3门考试是阶段性的，一门接着一门，那么可以通过重写onAdvance方法，来对每个阶段进行处理，这里只是打印出一条信息

public class PhaserTest3 {public static void main(String[] args) {Phaser phaser = new Phaser(5) {@Overrideprotected 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;default:System.out.println("phase:" + phase);return true;}}};for (int i = 0; i < 5; i++) {new Thread(new Student(phaser, "考生" + i)).start();}}public static class Student implements Runnable {private Phaser phaser;private String name;public Student(Phaser phaser, String name) {this.phaser = phaser;this.name = name;}@Overridepublic void run() {try {System.out.println(name + "：数学考试开始");Thread.sleep((int) (Math.random() * 10) * 1000);System.out.println(name + "考完数学,等待其他考生考完后参加下一场考试");phaser.arriveAndAwaitAdvance();//System.out.println(name + "：语文考试开始");Thread.sleep((int) (Math.random() * 10) * 1000);System.out.println(name + "考完语文,等待其他考生考完后参加下一场考试");phaser.arriveAndAwaitAdvance();//System.out.println(name + "：英语考试开始");Thread.sleep((int) (Math.random() * 10) * 1000);System.out.println(name + "考完英语,等待其他考生考完后参加下一场考试");phaser.arriveAndAwaitAdvance();//} catch (InterruptedException e) {e.printStackTrace();}}}
}
//考生0：数学考试开始
//考生2：数学考试开始
//考生4：数学考试开始
//考生1：数学考试开始
//考生3：数学考试开始
//考生0考完数学,等待其他考生考完后参加下一场考试
//考生4考完数学,等待其他考生考完后参加下一场考试
//考生3考完数学,等待其他考生考完后参加下一场考试
//考生2考完数学,等待其他考生考完后参加下一场考试
//考生1考完数学,等待其他考生考完后参加下一场考试
//所有考生考完数学....
//考生2：语文考试开始
//考生4：语文考试开始
//考生0：语文考试开始
//考生1：语文考试开始
//考生1考完语文,等待其他考生考完后参加下一场考试
//考生3：语文考试开始
//考生3考完语文,等待其他考生考完后参加下一场考试
//考生2考完语文,等待其他考生考完后参加下一场考试
//考生0考完语文,等待其他考生考完后参加下一场考试
//考生4考完语文,等待其他考生考完后参加下一场考试
//所有考生考完语文....
//考生0：英语考试开始
//考生2：英语考试开始
//考生4：英语考试开始
//考生3：英语考试开始
//考生1：英语考试开始
//考生1考完英语,等待其他考生考完后参加下一场考试
//考生2考完英语,等待其他考生考完后参加下一场考试
//考生4考完英语,等待其他考生考完后参加下一场考试
//考生3考完英语,等待其他考生考完后参加下一场考试
//考生0考完英语,等待其他考生考完后参加下一场考试
//所有考生考完英语....

    没完成一个阶段之后，都会调用onAdvance方法，且参数phase会递增，通过判断其值来区分各个阶段，然后进行特别的处理

    好了，Phaser就介绍到这里

    参考资料：

    http://whitesock.iteye.com/blog/1135457
    http://blog.csdn.net/andycpp/article/details/8838820

这篇关于Java多线程之----Phaser的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---