Phaser

转载自：
http://blog.youkuaiyun.com/luoyuyou/article/details/30257553
http://blog.youkuaiyun.com/chenssy/article/details/50000315

　　Phaser由Java7中推出，是Java SE 7中新增的一个使用同步工具，Phaser作为一个可复用的同步屏障来使用，在功能上相似于CyclicBarrier和CountDownLatch，但是支持更灵活的使用场景。
　　CyclicBarrier，允许一组线程互相等待，直到到达某个公共屏障点。它提供的await()可以实现让所有参与者在临界点到来之前一直处于等待状态。
　　CountDownLatch，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。它提供了await()、countDown()两个方法来进行操作。
　　在Phaser中，它把多个线程协作执行的任务划分为多个阶段，编程时需要明确各个阶段的任务，每个阶段都可以有任意个参与者，线程都可以随时注册并参与到某个阶段。

---

　　不像其它的屏障，在一个Phaser上注册的同步对象个数是可变的。任务能够在任意时刻被注册（构造函数中指定，或则使用register()/bulkRegister(int parties)动态调整），以及能够在到达之后可选择地撤销（使用arriveAndDeregister()）。像大多数基本的同步工具一样，注册和撤销只会影响内部的计数，他们不会在内部保留对注册对象的跟踪，所以任务不能通过查询得知自身是否被注册。（然而，能够引入类似的跟踪策略通过扩展这个类）。
　　类似于CyclicBarrier，一个Phaser能够重复用于等待。方法arriveAndAwaitAdvance有类似于CyclicBarrier.await的效果。phaser的每一代都伴随有一个阶段数。这个阶段数开始为0，当所有注册对象到达之后会递增，当达到Integer.MAX_VALUE时重新调整为0。阶段（phase）的使用可以让独立的几个行动抵达在phaser上等待其他的行动，通过两种类型的方法能够让已注册对象达到这一点：

• arrive()和arriveAndDeregister()，这些方法不会阻塞，但是返回一个伴随的阶段数；也就是这一次到达所使用的阶段数。当最后一个注册对象抵达之后，一个可选的行动将会被执行以及阶段数会递增。通过覆盖onAdvance方法，能够控制Phaser的结束。覆盖这个方法类似于通过提供一个屏障行动给CyclicBarrier，但是更灵活。
• arriveAndAwaitAdvance()，自己完成并等待其他参与者完成，进入阻塞，直到Phaser成功进入下个阶段。
• awaitAdvanc()需要一个参数指定一个抵达阶段数，以及返回当阶段数抵达一个不一样的阶段数。不同于CyclicBarrier的是，awaitAdvance会在中断之后继续等待。中断和超时的版本同时提供，但是中断和超时不会改变phaser的状态。如果需要，可以执行这些异常的伴随处理器，通过调用forceTermination。

　　一个phaser能够进入termination状态，这个状态可以通过isTerminated来检查。在结束之后，所有同步方法立刻返回不需要再等待阶段改变，返回一个负数。类似的，尝试在结束之后注册对象不会有任何影响。结束会在一个调用onAdvance返回true之后被触发。默认的实现返回true说明撤销操作已经使得注册者个数为0。正如在下面所说，可以通过覆盖这个方法从而让阶段数抵达一个阈值时结束phaser，从而实现固定的迭代操作。方法forceTermination也可以用作突然释放等待线程以使他们结束。

---

使用案例：
　　Phaser可以代替CountDownLatch来构建一个服务于多个对象只执行一次的行动。以下两种方式都可以达到CountDownLatch效果。

static void test002() {
    final Phaser phaser = new Phaser(1); //相当于CountDownLatch(1)
    for (int i = 0; i < 3; i++) {
        Runnable runnable = () -> {
            phaser.awaitAdvance(phaser.getPhase());        //countDownLatch.await()，等待第0阶段结束
            System.out.println(Thread.currentThread().getName() + " 执行任务...");
        };

        new Thread(runnable, "thread--" + i).start();
    }

    try {
        //等待1秒
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    phaser.arrive();  //countDownLatch.countDown()，注册对象到达，Phaser会进入下一阶段，即第0阶段结束
}

    static void test002() {
        final Phaser phaser = new Phaser(1);
        for (int i = 0; i < 3; i++) {
            Runnable runnable = () -> {
                phaser.register();
                phaser.arriveAndAwaitAdvance();
                System.out.println(Thread.currentThread().getName() + " 执行任务...");
            };
            new Thread(runnable, "thread--" + i).start();
        }

        try {
            //等待1秒
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        phaser.arriveAndDeregister();
    }

　　可以通过覆盖onAdvance来实现让多个线程把某些任务执行固定的次数。
　　

    static void test003() {
        final Phaser phaser = new Phaser() {
            /**
             * registeredParties:线程注册的数量
             */
            protected boolean onAdvance(int phase, int registeredParties) {
                System.out.println(Thread.currentThread().getName() + " 执行onAdvance方法, " +
                        "phase:" + phase + ", registeredParties=" + registeredParties);
                return phase >= 2 || registeredParties == 0;
            }
        };

        for (int i = 0; i < 3; i++) {
            Runnable runnable = () -> {
                do {
                    System.out.println(Thread.currentThread().getName() + " 开始执行任务...");
                    phaser.arriveAndAwaitAdvance();
                } while (!phaser.isTerminated());
            };

            phaser.register();
            new Thread(runnable, "thread-" + i).start();
        }
    }

　　如果主任务需要等待phaser的结束，那么它可以不断地注册自己从而执行一个类似循环：

phaser.register();
while (!phaser.isTerminated()) {
    phaser.arriveAndAwaitAdvance();
}