[笔记][Java7并发编程实战手册]3.6 并发阶段任务的运行phaser

于 2015-08-23 16:54:59 发布
阅读量1.2k 收藏
点赞数
分类专栏： Java7并发编程 文章标签： 并发 java 7 多线程 phaser
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mr_zhuqiang/article/details/47861515
版权

[笔记][Java7并发编程实战手册]系列目录

简介

Phaser是一个更强大的、更复杂的同步辅助类，可以代替CyclicBarrier CountDownLatch的功能，但是比他们更强大。
Phaser类机制是在每一步结束的位置对线程进行同步，当所有的线程都完成了这一步，才能进行下一步。
当我们有并发任务并且需要分解成几步执行的时候，这种机制就非常适合。
CyclicBarrier CountDownLatch 只能在构造时指定参与量，而phaser可以动态的增减参与量。

phaser 使用心得总结

  1. 使用phaser.arriveAndAwaitAdvance(); //等待参与者达到指定数量，才开始运行下面的代码
  2. 使用phaser.arriveAndDeregister(); //注销当前线程，该线程就不会进入休眠状态，也会从phaser的数量中减少
  3. 模拟代替CountDownLatch功能，只需要当前线程arriveAndAwaitAdvance()之后运行需要的代码之后，就arriveAndDeregister()取消当前线程的注册。
  4. phaser有一个重大特性，就是不必对它的方法进行异常处理。置于休眠的线程不会响应中断事件，不会抛出interruptedException异常， 只有一个方法会响应：AwaitAdvanceInterruptibly(int phaser).

其他api

  1. arrive()：这个方法通知phase对象一个参与者已经完成了当前阶段，但是它不应该等待其他参与者都完成当前阶段，必须小心使用这个方法，因为它不会与其他线程同步。

  2. awaitAdvance(int phase)：如果传入的阶段参数与当前阶段一致，这个方法会将当前线程至于休眠，直到这个阶段的所有参与者都运行完成。如果传入的阶段参数与当前阶段不一致，这个方法立即返回。

  3. awaitAdvanceInterruptibly(int phaser):这个方法跟awaitAdvance(int phase)一样，不同处是：该访问将会响应线程中断。会抛出interruptedException异常

将参与者注册到phaser中：

  1. register():将一个新的参与者注册到phase中，这个新的参与者将被当成没有执完本阶段的线程。
  2. bulkRegister(int parties)：将指定数目的参与者注册到phaser中，所有这些新的参与者都将被当成没有执行完本阶段的线程。

减少参与者
　　只提供了一个方法来减少参与者：arriveAndDeregister():告知phaser对应的线程已经完成了当前阶段，并它不会参与到下一阶段的操作中。

强制终止
　　当一个phaser么有参与者的时候，它就处于终止状态，
　　使用forceTermination()方法来强制phaser进入终止状态，不管是否存在未注册的参与线程，当一个线程出现错误时，强制终止phaser是很有意义的。

　　当phaser处于终止状态的时候，arriveAndAwaitAdvance() 和 awaitAdvance() 立即返回一个负数，而不再是一个正值了，如果知道phaser可能会被终止，就需要验证这些方法的值，以确定phaser是不是被终止了。
被终止的phaser不会保证参与者的同步。

什么是阶段？

为什么要搞懂阶段？：因为在后面一章节中，会利用覆盖方法，来达到在每一个阶段切换的时候执行一些代码。 所以要明确这个阶段的概念；

phaser里面一个重要概念，awaitAdvance(int phase) 中的阶段是什么？如果不测试下，还真不明白这个阶段到底是什么，其实可以说成是步骤，看下面的代码示例，我觉得下面代码的示例，才是正确的示范phase的阶段用法：

/**
 * Created by zhuqiang on 2015/8/23 0023.
 */
public class Client {
    public static void main(String[] args) throws InterruptedException {
        final Phaser phaser = new Phaser(3); //创建3个参与量
        for (int i = 0; i < 3; i++) {
            TimeUnit.SECONDS.sleep(1);
            Thread t = new Thread(new PhaseTest(phaser));
            t.start();
        }
//        TimeUnit.SECONDS.sleep(3);  // 1
//        for (int i = 0; i < 2; i++) { //2
//            new Thread(new PhaseTest4(phaser)).start();
//        }
    }

    static class PhaseTest implements Runnable {
        private Phaser phaser;

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

        @Override
        public void run() {
            System.out.printf("步骤%s-->当前阶段：%s-->当前线程%s\n", 1, phaser.getPhase(), Thread.currentThread().getName());
            phaser.arriveAndAwaitAdvance();  // 完成了一个阶段，参与者将等待其他参与者完成当前阶段任务
            System.out.printf("步骤%s-->当前阶段：%s-->当前线程%s\n", 2, phaser.getPhase(), Thread.currentThread().getName());
            phaser.arriveAndAwaitAdvance();
            System.out.printf("步骤%s-->当前阶段：%s-->当前线程%s\n", 3, phaser.getPhase(), Thread.currentThread().getName());
            phaser.arriveAndDeregister(); //注销当前线程
//            System.out.printf("步骤%s-->当前阶段：%s-->当前线程%s\n", 4, phaser.getPhase(), Thread.currentThread().getName());  //该步骤不能写到 arriveAndDeregister后面，因为这个时候phaser已经是终止状态了，如果开打开代码会看到负值的状态
        }
    }

    static class PhaseTest4 implements Runnable {
        private Phaser phaser;

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

        @Override
        public void run() {
//            phaser.register();  // 3
            System.out.printf("步骤%s-->当前阶段：%s-->当前线程%s\n", 1, phaser.getPhase(), Thread.currentThread().getName());
            phaser.arriveAndAwaitAdvance();  // 完成了一个阶段，参与者将等待其他参与者完成当前阶段任务
            System.out.printf("步骤%s-->当前阶段：%s-->当前线程%s\n", 2, phaser.getPhase(), Thread.currentThread().getName());
            phaser.arriveAndAwaitAdvance();
            System.out.printf("步骤%s-->当前阶段：%s-->当前线程%s\n", 3, phaser.getPhase(), Thread.currentThread().getName());
            phaser.arriveAndDeregister(); //注销当前线程
        }
    }

某一次的运行结果：

步骤1-->当前阶段：0-->当前线程Thread-0
步骤1-->当前阶段：0-->当前线程Thread-1
步骤1-->当前阶段：0-->当前线程Thread-2
步骤2-->当前阶段：1-->当前线程Thread-2
步骤2-->当前阶段：1-->当前线程Thread-0
步骤2-->当前阶段：1-->当前线程Thread-1
步骤3-->当前阶段：2-->当前线程Thread-1
步骤3-->当前阶段：2-->当前线程Thread-0
步骤3-->当前阶段：2-->当前线程Thread-2

运行结果说明：
可以看到，我们手动的打印了每一个步骤的执行和阶段， 可以看出来，步骤对应的阶段是从0开始，就和索引是一样的。 而只注册了3个参与者

该示例中有3处测试注释代码，以下三处，根据解说能验证不同的结论

//        TimeUnit.SECONDS.sleep(3);  // 1   // 休眠是为了让phaser进入终止状态
//        for (int i = 0; i < 2; i++) { //2  
//            new Thread(new PhaseTest4(phaser)).start();
//        }
//        phaser.register();  // 3  把当前线程注册到 phaser中

1.验证phaser的参数数量没有和参与者绑定，先到先得。参与数量与实际参与数量不一致将导致错误的并发同步
需要打开的注释代码有 2
某一次的运行结果：

步骤1-->当前阶段：0-->当前线程Thread-0
步骤1-->当前阶段：0-->当前线程Thread-1
步骤1-->当前阶段：0-->当前线程Thread-2
步骤2-->当前阶段：1-->当前线程Thread-1
步骤2-->当前阶段：1-->当前线程Thread-2
步骤2-->当前阶段：1-->当前线程Thread-0
步骤1-->当前阶段：1-->当前线程Thread-4
步骤1-->当前阶段：1-->当前线程Thread-3
步骤3-->当前阶段：2-->当前线程Thread-1
步骤3-->当前阶段：2-->当前线程Thread-2
步骤3-->当前阶段：2-->当前线程Thread-0
步骤2-->当前阶段：3-->当前线程Thread-4
步骤3-->当前阶段：-2147483644-->当前线程Thread-4
步骤2-->当前阶段：3-->当前线程Thread-3
步骤3-->当前阶段：-2147483644-->当前线程Thread-3

结果说明：可以看出来，结果是混乱的，注册的参与者和实际参与者不一致将会导致错误的同步结果。有并发抢注

2.验证验证phaser的参数数量没有和参与者绑定，先到先得。并且当phaser终止状态下，phaser将失去作用
需要打开的注释代码有 1，2

步骤1-->当前阶段：0-->当前线程Thread-0
步骤1-->当前阶段：0-->当前线程Thread-1
步骤1-->当前阶段：0-->当前线程Thread-2
步骤2-->当前阶段：1-->当前线程Thread-2
步骤2-->当前阶段：1-->当前线程Thread-0
步骤2-->当前阶段：1-->当前线程Thread-1
步骤3-->当前阶段：2-->当前线程Thread-1
步骤3-->当前阶段：2-->当前线程Thread-0
步骤3-->当前阶段：2-->当前线程Thread-2
步骤1-->当前阶段：-2147483645-->当前线程Thread-3
步骤1-->当前阶段：-2147483645-->当前线程Thread-4
步骤2-->当前阶段：-2147483645-->当前线程Thread-4
步骤3-->当前阶段：-2147483645-->当前线程Thread-4
步骤2-->当前阶段：-2147483645-->当前线程Thread-3
步骤3-->当前阶段：-2147483645-->当前线程Thread-3

结果说明：
可以看出来，终止状态后，的线程再继续使用phaser将不会起作用。

3.验证动态的新增注册
需要打开的注释代码有 2，3

步骤1-->当前阶段：0-->当前线程Thread-0
步骤1-->当前阶段：0-->当前线程Thread-1
步骤1-->当前阶段：0-->当前线程Thread-2
步骤2-->当前阶段：1-->当前线程Thread-2
步骤2-->当前阶段：1-->当前线程Thread-1
步骤1-->当前阶段：1-->当前线程Thread-3
步骤2-->当前阶段：1-->当前线程Thread-0
步骤1-->当前阶段：1-->当前线程Thread-4
步骤2-->当前阶段：2-->当前线程Thread-4
步骤3-->当前阶段：2-->当前线程Thread-2
步骤3-->当前阶段：2-->当前线程Thread-0
步骤2-->当前阶段：2-->当前线程Thread-3
步骤3-->当前阶段：2-->当前线程Thread-1
步骤3-->当前阶段：3-->当前线程Thread-3
步骤3-->当前阶段：3-->当前线程Thread-4

结果说明：只要不是终止状态下，就可以动态的把线程注册到phaser中，三个步骤本来只有3个阶段的，现在出现了第4个阶段，我的猜想是：线程3没有赶上第0个阶段，从1阶段开始，但是前面的线程已经执行完了0阶段，而线程3的阶段就必须得往后推移一个了。

示例

替代CountDownLatch的功能

/**
 * Created by zhuqiang on 2015/8/23 0023.
 */
public class Client {
    public static void main(String[] args) throws InterruptedException {
        final Phaser phaser = new Phaser(3); //创建3个参与量
        for (int i = 0; i < 3; i++) {
            TimeUnit.SECONDS.sleep(1);  //每次创建线程 都休眠1秒，方便看到使用该arriveAndAwaitAdvance方法之后的效果，是不是都等待人都到齐后下面的代码才继续执行
            new Thread(new CountDownLatchTest(phaser)).start();
        }
    }

    static class CountDownLatchTest implements Runnable {
        private Phaser phaser;

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

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + ",进入了线程，不过人还没有到齐：到达并带等待的数量" + phaser.getArrivedParties());
            phaser.arriveAndAwaitAdvance();  //等待参与者达到指定数量，才开始运行，在该列中，该行代码之前的代码并行，该行代码之后的代码并行
            System.out.println(Thread.currentThread().getName() + ",人都到齐了执行中：,到达并带等待的数量" + phaser.getArrivedParties());
            phaser.arriveAndDeregister(); //注销当前线程
            System.out.println(Thread.currentThread().getName() + ",线程注销了：,到达并带等待的数量" + phaser.getArrivedParties());
        }
    }
}

某一次的运行结果：

Thread-0,进入了线程，不过人还没有到齐：到达并带等待的数量0
Thread-1,进入了线程，不过人还没有到齐：到达并带等待的数量1
Thread-2,进入了线程，不过人还没有到齐：到达并带等待的数量2
Thread-2,人都到齐了执行中：,到达并带等待的数量0
Thread-0,人都到齐了执行中：,到达并带等待的数量0
Thread-0,线程注销了：,到达并带等待的数量0
Thread-2,线程注销了：,到达并带等待的数量0
Thread-1,人都到齐了执行中：,到达并带等待的数量0
Thread-1,线程注销了：,到达并带等待的数量0

简单示例，phaser分步骤运行

场景：模拟3个人进入超市买东西的过程：
1. 挑选东西
2. 通过收银员通道（如果购买了商品，则需要进入第3步：付款）
3. 付款

/**
 * Created by zhuqiang on 2015/8/23 0023.
 */
public class Client {

    public static void main(String[] args) throws InterruptedException {
        final Phaser phaser = new Phaser(3); //创建3个参与量
        ArrayList<Thread> list = new ArrayList<Thread>();
        for (int i = 0; i < 3; i++) {
            TimeUnit.SECONDS.sleep(1);  //每次创建线程 都休眠1秒，方便看到使用该arriveAndAwaitAdvance方法之后的效果，是不是都等待人都到齐后下面的代码才继续执行
            Thread thread = new Thread(new Persion(phaser));
            list.add(thread);
            thread.start();
        }

        for (Thread t : list) {
            t.join();
        }

        System.out.println("phaser是否是终止状态：" + phaser.isTerminated()); // 当参与者数量，被取消完的时候，就返回true，如果还有未被取消的数量，该phaser就是活动状态
    }


}

class Persion implements Runnable {
    private boolean goods;   //标识是否购买商品
    private Phaser phaser;

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

    @Override
    public void run() {
//        choose();//挑选商品
//        phaser.arriveAndAwaitAdvance();  //等待所有人都把商品挑选完，才执行检查步骤
//        if(check()){
//            phaser.arriveAndAwaitAdvance();  //需要付款的，等待所有人检测完
//            pay();
            phaser.arriveAndDeregister(); //取消当前线程的注册
//        }else{ //不需要付款的，注销当前线程
//            phaser.arriveAndDeregister();
//        }
        /***
         * 上面的代码  和下面的代码等效，但是意义却是不一样的。
         * 只是把各个线程的 注册等待  和 取消注册等待  放到每一个具体的方法中了，
         * 这样的好处是，假设有这样一个场景： 我们可以通过phaser.isTerminated() 是否还是活动状态来判断  这个任务是否是正常完成的。如果有未取消的线程，那么就说明其中一个线程肯定出错了
         **/
        choose();//挑选商品
        if (check()) {
            pay();
        }
    }

    // 第一步：挑选商品
    public void choose() {
        phaser.arriveAndAwaitAdvance();
        System.out.printf("%s,挑选商品中\n", Thread.currentThread().getName());
        double v = Math.random() * 2;
        if (v > 1) {
            goods = true;  // 大于1 就表示购买了商品。需要进行付款
        } else {
            goods = false;
        }
    }

    // 第二步：检查是否购买了商品
    public boolean check() {
        phaser.arriveAndAwaitAdvance();  //需要付款的，等待所有人检测完
        System.out.printf("%s,检查中,%S\n", Thread.currentThread().getName(), goods ? "购买了商品,需要付款" : "没有购买商品,不需要付款");
        if(goods){
            phaser.arriveAndAwaitAdvance();  //需要付款的，等待所有人检测完
        }else{
            phaser.arriveAndDeregister();
        }
        return goods;
    }

    //第三步：付款
    public void pay() {
        System.out.printf("%s,购买了商品，正在付款\n", Thread.currentThread().getName());
        phaser.arriveAndDeregister(); //取消当前线程的注册
    }
}

某一次的运行结果：

Thread-0,挑选商品中
Thread-2,挑选商品中
Thread-1,挑选商品中
Thread-0,检查中,购买了商品,需要付款
Thread-2,检查中,购买了商品,需要付款
Thread-1,检查中,没有购买商品,不需要付款
Thread-0,购买了商品，正在付款
Thread-2,购买了商品，正在付款
phaser是否是终止状态：true

结果说明：
　　可以看到上面的运行结果，每个阶段，都会被等待执行完成后，再一起执行。

代码有毒 mrcode
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值