Phaser

public class Phaser
extends Object

可重复使用的同步屏障，功能类似于 CyclicBarrier和 CountDownLatch但支持更灵活的使用。

注册。 与其他障碍的情况不同， 登记在移相器上进行同步的参与方的数量可能会随时间而变化。 任务可以在任何时间（使用的方法来注册register() ， bulkRegister(int) ，或构造建立各方的初始数的形式），和（使用任何抵达时任选注销arriveAndDeregister() ）。 与大多数基本同步结构一样，注册和注销只影响内部计数; 他们不建立任何进一步的内部簿记，因此任务不能查询他们是否已注册。 （但是，你可以通过继承这个类来引入这样的簿记。）

同步。 像CyclicBarrier一样， Phaser可能会一再等待。 方法arriveAndAwaitAdvance()作用类似于CyclicBarrier.await 。 每代相位器都有相关的相位编号。 阶段编号从零开始，并在所有各方到达相位器时前进，在达到Integer.MAX_VALUE后回零。 阶段号的使用能够在到达相位器时以及在等待其他时通过可能由任何注册方引用的两种方法来独立控制动作：

• Arrival. Methods arrive() and arriveAndDeregister() record arrival. These methods do not block, but return an associated arrival phase number; that is, the phase number of the phaser to which the arrival applied. When the final party for a given phase arrives, an optional action is performed and the phase advances. These actions are performed by the party triggering a phase advance, and are arranged by overriding method onAdvance(int, int), which also controls termination. Overriding this method is similar to, but more flexible than, providing a barrier action to a CyclicBarrier.
• Waiting. Method awaitAdvance(int) requires an argument indicating an arrival phase number, and returns when the phaser advances to (or is already at) a different phase. Unlike similar constructions using CyclicBarrier, method awaitAdvance continues to wait even if the waiting thread is interrupted. Interruptible and timeout versions are also available, but exceptions encountered while tasks wait interruptibly or with timeout do not change the state of the phaser. If necessary, you can perform any associated recovery within handlers of those exceptions, often after invoking forceTermination. Phasers may also be used by tasks executing in a ForkJoinPool. Progress is ensured if the pool's parallelismLevel can accommodate the maximum number of simultaneously blocked parties.

终止。 移相器可以进入终止状态，可以使用方法isTerminated()进行检查。 终止时，所有同步方法立即返回而不等待提前，如负返回值所示。 同样，终止时注册的企图无效。 当调用onAdvance返回true时终止触发。 如果注销导致注册方的数量变为零，则默认实现返回true 。 如下图所示，当相位器控制具有固定迭代次数的动作时，在当前相位数达到阈值时重写此方法以导致终止常常是方便的。 方法forceTermination()也可以突然释放等待线程并允许它们终止。

分层。 Phasers可以分层 （即，构建在树结构中）以减少争用。 具有大量当事方的阶段公司可能会遭遇严重的同步争用成本，反而可能会设立一些分阶段的小组以共享一个共同的母公司。 这可能会大大增加吞吐量，即使它会导致更高的每操作开销。

在分层阶段的树中，自动管理子阶段的注册和注销。 每当一个儿童相位器的注册方数量变为非零时（如Phaser(Phaser, int)构造函数， register()或bulkRegister(int) ），该孩子相位器就会向其父母注册。 每当注册方的数量因调用arriveAndDeregister()而变为零时，儿童移相器就会从其父母注销。

监测。 虽然同步方法只能由注册方调用，但任何调用者都可以监控移相器的当前状态。 在任何时候，总共有getRegisteredParties()方，其中getArrivedParties()已到达目前阶段（ getPhase() ）。 剩下的（ getUnarrivedParties() ）各方到达时，阶段进展。 这些方法返回的值可能反映瞬态状态，所以通常不用于同步控制。 方法toString()以便于非正式监控的形式返回这些状态查询的快照。

样品用量：

可以使用Phaser而不是CountDownLatch来控制服务于可变数量的各方的一次性动作。 典型的习惯用法是将该方法设置为第一个寄存器，然后启动操作，然后取消注册，如下所示：

 void runTasks(List<Runnable> tasks) {
   final Phaser phaser = new Phaser(1); // "1" to register self
   // create and start threads
   for (final Runnable task : tasks) {
     phaser.register();
     new Thread() {
       public void run() {
         phaser.arriveAndAwaitAdvance(); // await all creation
         task.run();
       }
     }.start();
   }

   // allow threads to start and deregister self
   phaser.arriveAndDeregister();
 }

导致一组线程重复执行给定迭代次数的一种方法是覆盖 onAdvance ：

 void startTasks(List<Runnable> tasks, final int iterations) {
   final Phaser phaser = new Phaser() {
     protected boolean onAdvance(int phase, int registeredParties) {
       return phase >= iterations || registeredParties == 0;
     }
   };
   phaser.register();
   for (final Runnable task : tasks) {
     phaser.register();
     new Thread() {
       public void run() {
         do {
           task.run();
           phaser.arriveAndAwaitAdvance();
         } while (!phaser.isTerminated());
       }
     }.start();
   }
   phaser.arriveAndDeregister(); // deregister self, don't wait
 }

 // ...
   phaser.register();
   while (!phaser.isTerminated())
     phaser.arriveAndAwaitAdvance();

可以使用相关的结构来等待上下文中的特定阶段编号，您可以确定该阶段不会环绕Integer.MAX_VALUE 。 例如：

 void awaitPhase(Phaser phaser, int phase) {
   int p = phaser.register(); // assumes caller not already registered
   while (p < phase) {
     if (phaser.isTerminated())
       // ... deal with unexpected termination
     else
       p = phaser.arriveAndAwaitAdvance();
   }
   phaser.arriveAndDeregister();
 }

要使用相位器树创建一组n任务，您可以使用以下形式的代码，假定一个具有构造函数的Task类接受在构建时注册的Phaser 。 在调用build(new Task[n], 0, n, new Phaser()) ，可以开始这些任务，例如通过提交给池：

 void build(Task[] tasks, int lo, int hi, Phaser ph) {
   if (hi - lo > TASKS_PER_PHASER) {
     for (int i = lo; i < hi; i += TASKS_PER_PHASER) {
       int j = Math.min(i + TASKS_PER_PHASER, hi);
       build(tasks, i, j, new Phaser(ph));
     }
   } else {
     for (int i = lo; i < hi; ++i)
       tasks[i] = new Task(ph);
       // assumes new Task(ph) performs ph.register()
   }
 }

实施注意事项 ：该实施将参与方的最大数目限制为65535.试图注册额外参与方的结果为IllegalStateException 。 但是，您可以并且应该创建分层的阶段器来容纳任意数量的参与者。

Summary

Inherited methods

From class java.lang.Object Object clone() 创建并返回此对象的副本。 boolean equals(Object obj) 指示其他某个对象是否“等于”这一个。 void finalize() 当垃圾收集确定没有更多对该对象的引用时，由对象上的垃圾回收器调用。 final Class<?> getClass() 返回此 Object的运行时类。 int hashCode() 返回对象的哈希码值。 final void notify() 唤醒正在等待该对象监视器的单个线程。 final void notifyAll() 唤醒在该对象监视器上等待的所有线程。 String toString() 返回对象的字符串表示形式。 final void wait(long millis, int nanos) 导致当前线程等待，直到另一个线程为此对象调用 notify()方法或 notifyAll()方法，或者某个其他线程中断当前线程或者经过了一定的实时时间。 final void wait(long millis) 导致当前线程等待，直到另一个线程调用此对象的 notify()方法或 notifyAll()方法或经过了指定的时间量。 final void wait() 导致当前线程等待，直到另一个线程调用此对象的 notify()方法或 notifyAll()方法。

Public constructors

Phaser ()

Phaser (int parties)

Phaser (Phaser parent)

Phaser (Phaser parent, 
                int parties)

Public methods

int arrive ()

int arriveAndAwaitAdvance ()

int arriveAndDeregister ()

int awaitAdvance (int phase)

int awaitAdvanceInterruptibly (int phase)

int awaitAdvanceInterruptibly (int phase, 
                long timeout, 
                TimeUnit unit)

int bulkRegister (int parties)

void forceTermination ()

int getArrivedParties ()

Phaser getParent ()

int getPhase ()

int getRegisteredParties ()

Phaser getRoot ()

int getUnarrivedParties ()

boolean isTerminated ()

int register ()

String toString ()

Protected methods

boolean onAdvance (int phase, 
                int registeredParties)

 Phaser phaser = new Phaser() {
   protected boolean onAdvance(int phase, int parties) { return false; }
 }