Java并发——Phaser详解

于 2020-06-22 23:28:14 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： 并发编程 文章标签： Phaser java 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cold___play/article/details/106909344
版权

Phaser

Phaser中文翻译为相位器。它与CountDownLatch非常相似，允许我们协调线程的执行。与CountDownLatch相比，它具有一些额外的功能。

Phaser是在线程动态数需要继续执行之前等待的屏障。在CountDownLatch中，该数字无法动态配置，需要在创建实例时提供。
在这里插入图片描述

arriveAndAwaitAdvanve()方法：
方arriveAndAwaitAdvanceo的作用与 CountDownLatch类中的awai()方法大体一样,通过从方法的名称解释来看, arrive是到达的意思,wait是等待的意思,而 advance是前进、促进的意思,所以执行这个方法的作用就是当前线程已经到达屏障,在此等待一段时间,等条件满足后继续向下一个屏障继续执行。

public class PrintTools {
    public static Phaser phaser;

    public static void methodA() {
        System.out.println(Thread.currentThread().getName() + " A1 begin=" + System.currentTimeMillis());
        phaser.arriveAndAwaitAdvance();
        System.out.println(Thread.currentThread().getName() + " A1 end=" + System.currentTimeMillis());

        System.out.println(Thread.currentThread().getName() + " A2 begin=" + System.currentTimeMillis());
        phaser.arriveAndAwaitAdvance();
        System.out.println(Thread.currentThread().getName() + " A2 end=" + System.currentTimeMillis());
    }

    public static void methodB() {
        try {
            System.out.println(Thread.currentThread().getName() + " A1 begin=" + System.currentTimeMillis());
            phaser.arriveAndAwaitAdvance();
            System.out.println(Thread.currentThread().getName() + " A1 end=" + System.currentTimeMillis());

            System.out.println(Thread.currentThread().getName() + " A2 begin=" + System.currentTimeMillis());
            Thread.sleep(5000);
            phaser.arriveAndAwaitAdvance();
            System.out.println(Thread.currentThread().getName() + " A2 end=" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Phaser p = new Phaser(3);
        PrintTools.phaser = p;

        ThreadA a = new ThreadA(phaser);
        a.setName("A");
        a.start();

        ThreadB b = new ThreadB(phaser);
        b.setName("B");
        b.start();

        ThreadC c = new ThreadC(phaser);
        c.setName("C");
        c.start();
    }
}

public class ThreadA extends Thread {
    private Phaser phaser;

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

    @Override
    public void run() {
        PrintTools.methodA();
    }
}
public class ThreadB extends Thread {
    private Phaser phaser;

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

    @Override
    public void run() {
        PrintTools.methodA();
    }
}
public class ThreadC extends Thread {
    private Phaser phaser;

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

    @Override
    public void run() {
        PrintTools.methodB();
    }
}

在这里插入图片描述
注意：当arriveAndAwaitAdvance()调用时，如果计数不足，则线层呈阻塞状态，不继续向下运行
修改methodB()方法
在这里插入图片描述
再次运行，输出如下：
在这里插入图片描述

arriveAndDeregister()方法：
当线程到达屏障后，退出屏障的阻塞，并且使parties值减一。

public class Deregister {
    public static void main(String[] args) {
        Phaser phaser = new Phaser(2);
        MyThread t = new MyThread(phaser);
        t.start();
        System.out.println("main begin" + System.currentTimeMillis());
        System.out.println(phaser.getRegisteredParties());
        phaser.arriveAndDeregister();//退出阻塞，计数-1
        System.out.println(phaser.getRegisteredParties());
        System.out.println("main end" + System.currentTimeMillis());
    }
}

class MyThread extends Thread{
    private Phaser phaser;

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

    @Override
    public void run() {
        phaser.arriveAndAwaitAdvance();
        System.out.println("MyThread end");
    }
}

在这里插入图片描述

getPhase()和onAdvance()：

方法getPhase()获取的是已经到达第几个屏障。

public class getPhase {

    public static void main(String[] args) throws InterruptedException {
        Phaser phaser = new Phaser(1);
        TestThread t = new TestThread(phaser);
        t.start();
    }


}
class TestThread extends Thread {
    private Phaser phaser;

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

    @Override
    public void run() {
        System.out.println("A begin");
        phaser.arriveAndAwaitAdvance();
        System.out.println("A end phase value=" + phaser.getPhase());

        System.out.println("A begin");
        phaser.arriveAndAwaitAdvance();
        System.out.println("A end phase value=" + phaser.getPhase());

        System.out.println("A begin");
        phaser.arriveAndAwaitAdvance();
        System.out.println("A end phase value=" + phaser.getPhase());
    }
}

在这里插入图片描述

onAdvance()的作用是通过新的屏障时被调用：

public class onAdvance {
    public static void main(String[] args) throws InterruptedException {
        Phaser phaser = new Phaser(2) {
            @Override
            protected boolean onAdvance(int phase, int registeredParties) {
                System.out.println("onAdvence被调用！");
                return true;
                //返回true表示，下一次到达屏障不等待了，Phaser呈无效/销毁的状态
                //返回false表示，下一次到达屏障Phaser继续工作
            }
        };

        //第一次通过屏障
        AThread a = new AThread(phaser);
        a.start();
        phaser.arriveAndAwaitAdvance();


        //第二次
        Thread.sleep(2000);
        BThread b = new BThread(phaser);
        b.start();
        System.out.println("main end");
    }
}

class AThread extends Thread {
    private Phaser phaser;

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

    @Override
    public void run() {
        System.out.println("A begin");
        phaser.arriveAndAwaitAdvance();
        System.out.println("A end");
    }
}

class BThread extends Thread {
    private Phaser phaser;

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

    @Override
    public void run() {
        System.out.println("B begin");
        phaser.arriveAndAwaitAdvance();
        System.out.println("B end");
    }
}

onAdvance返回true，下一次到达屏障不阻塞
在这里插入图片描述

修改返回值为false，下一次到达屏障正常阻塞
在这里插入图片描述

getRegisteredParities():
获得注册的parties数量。

register():
每执行一次方法，就动态添加一个parties值。

bulkRegister()：
批量增加parties数量。

getArrivedParties():
获得已经被使用的parties个数。

getUnarrivedParties()：
获得未被使用的parties个数。

public class Parties {
    public static void main(String[] args) {
        Phaser phaser = new Phaser(5);
        System.out.println(phaser.getRegisteredParties());//5

        phaser.register();
        System.out.println(phaser.getRegisteredParties());//6

        phaser.bulkRegister(10);
        System.out.println(phaser.getRegisteredParties());//16

        System.out.println(phaser.getArrivedParties());//0
        System.out.println(phaser.getUnarrivedParties());//16
    }
}

arrive()方法：
方法arrive()的作用是使parties 值加1，并且不在屏障处等待，直接向下面的代码继续运行，并且Phaser类有计数重置功能。

public class TestArrive {
    public static void main(String[] args) {
        Phaser phaser = new Phaser(2){
            @Override
            protected boolean onAdvance(int phase, int registeredParties) {
                System.out.println("到达屏障，但未通过！phase=" + phase + " registeredParties=" + registeredParties);
                return super.onAdvance(phase, registeredParties);
            }
        };

        System.out.println("A1 getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() +
                " getArrivedParties=" + phaser.getArrivedParties());
        phaser.arrive();
        System.out.println("A1 getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() +
                " getArrivedParties=" + phaser.getArrivedParties());

        System.out.println("A2 getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() +
                " getArrivedParties=" + phaser.getArrivedParties());
        phaser.arrive();
        System.out.println("A2 getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() +
                " getArrivedParties=" + phaser.getArrivedParties());

        System.out.println("B1 getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() +
                " getArrivedParties=" + phaser.getArrivedParties());
        phaser.arrive();
        System.out.println("B1 getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() +
                " getArrivedParties=" + phaser.getArrivedParties());

        System.out.println("B2 getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() +
                " getArrivedParties=" + phaser.getArrivedParties());
        phaser.arrive();
        System.out.println("B2 getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() +
                " getArrivedParties=" + phaser.getArrivedParties());
    }
}

在这里插入图片描述
方法arrive()的功能是使getArrivedParties()计数加1，不等待其他线程到达屏障。
在控制台中多次出现getArrivedParties=0的运行结果，所以可以分析出Phaser类在经过屏障点后计数能被重置。

awaitAdvance(int phase):
如果传人参数phase值和当前getPhase()方法返回值一样，则在屏障处等待，否则继续向下面运行，有些类似于旁观者的作用，当观察的条件满足了就等待(旁观),如果条件不满足，则程序向下继续运行。

public class AwaitAdvance {
    public static void main(String[] args) {
        Phaser phaser = new Phaser(1);
        phaser.awaitAdvance(1);//不一样，通过
        System.out.println("通过第一次");

        phaser.arriveAndAwaitAdvance();
        phaser.awaitAdvance(1);//一样，阻塞
        System.out.println("通过第二次");
    }
}

在这里插入图片描述

awaitAdvanceInterruptibly(int):
可中断的。
awaitAdvanceInterruptibly(int ,long, TImeUnit):
带超时，且可中断。

forceTermination()和isTerminated():
方法forceTermination()使Phaser对象的屏障功能失效，而方法isTerminated()是判断Phaser对象是否已经呈销毁状态。

public class Termination {
    public static void main(String[] args) {
        Phaser phaser = new Phaser(2);
        phaser.forceTermination();
        phaser.arriveAndAwaitAdvance();//失效，所以不阻塞
        System.out.println(phaser.isTerminated());//true
    }
}
控制Phaser类的运行时机

前面的示例都是线程一起到达屏障后继续运行，有些情况下是需要进行控制的，也就是到达屏障后不允许继续运行。
默认的运行效果：

public class RunDemo {
    public static void main(String[] args) {
        Phaser phaser = new Phaser(3);
        for (int i = 0; i < 3; i++) {
            RunThread t = new RunThread(phaser);
            t.start();
        }
    }
}

class RunThread extends Thread {
    private Phaser phaser;

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

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " A1 begin=" + System.currentTimeMillis());
        phaser.arriveAndAwaitAdvance();
        System.out.println(Thread.currentThread().getName() + " A1 end=" + System.currentTimeMillis());
    }
}

在这里插入图片描述

可控的运行时机：

public static void main(String[] args) throws InterruptedException {
        Phaser phaser = new Phaser(3);
        phaser.register();
        for (int i = 0; i < 3; i++) {
            RunThread t = new RunThread(phaser);
            t.start();
        }
        Thread.sleep(2000);
        phaser.arriveAndAwaitAdvance();
    }

在这里插入图片描述
此实验说明运行的时机是可以通过逻辑控制的，主要的原理就是计数+1,然后通过逻辑代码的方式来决定线程是否继续向下运行。

吴声子夜歌
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值