--- jsr166/src/jsr166y/Phaser.java	2009/08/12 02:24:35	1.28
+++ jsr166/src/jsr166y/Phaser.java	2009/08/19 23:05:32	1.34
@@ -95,15 +95,15 @@ import java.util.concurrent.locks.LockSu
  * first register, then start the actions, then deregister, as in:
  *
  *  <pre> {@code
- * void runTasks(List<Runnable> list) {
+ * void runTasks(List<Runnable> tasks) {
  *   final Phaser phaser = new Phaser(1); // "1" to register self
  *   // create and start threads
- *   for (Runnable r : list) {
+ *   for (Runnable task : tasks) {
  *     phaser.register();
  *     new Thread() {
  *       public void run() {
  *         phaser.arriveAndAwaitAdvance(); // await all creation
- *         r.run();
+ *         task.run();
  *       }
  *     }.start();
  *   }
@@ -116,19 +116,19 @@ import java.util.concurrent.locks.LockSu
  * for a given number of iterations is to override {@code onAdvance}:
  *
  *  <pre> {@code
- * void startTasks(List<Runnable> list, final int iterations) {
+ * void startTasks(List<Runnable> tasks, final int iterations) {
  *   final Phaser phaser = new Phaser() {
  *     public boolean onAdvance(int phase, int registeredParties) {
  *       return phase >= iterations || registeredParties == 0;
  *     }
  *   };
  *   phaser.register();
- *   for (Runnable r : list) {
+ *   for (Runnable task : tasks) {
  *     phaser.register();
  *     new Thread() {
  *       public void run() {
  *         do {
- *           r.run();
+ *           task.run();
  *           phaser.arriveAndAwaitAdvance();
  *         } while(!phaser.isTerminated();
  *       }
@@ -169,7 +169,7 @@ import java.util.concurrent.locks.LockSu
  *
  * <p><b>Implementation notes</b>: This implementation restricts the
  * maximum number of parties to 65535. Attempts to register additional
- * parties result in IllegalStateExceptions. However, you can and
+ * parties result in {@code IllegalStateException}. However, you can and
  * should create tiered phasers to accommodate arbitrarily large sets
  * of participants.
  *
@@ -535,12 +535,14 @@ public class Phaser {
 
     /**
      * Awaits the phase of the barrier to advance from the given phase
-     * value, or returns immediately if the current phase of the barrier
-     * is not equal to the given phase value or this barrier is
-     * terminated.
+     * value, returning immediately if the current phase of the
+     * barrier is not equal to the given phase value or this barrier
+     * is terminated.
      *
      * @param phase the phase on entry to this method
-     * @return the phase on exit from this method
+     * @return the current barrier phase number upon exit of
+     * this method, or a negative value if terminated or
+     * argument is negative
      */
     public int awaitAdvance(int phase) {
         if (phase < 0)
@@ -556,13 +558,16 @@ public class Phaser {
     }
 
     /**
-     * Awaits the phase of the barrier to advance from the given
-     * value, or returns immediately if argument is negative or this
-     * barrier is terminated, or throws InterruptedException if
-     * interrupted while waiting.
+     * Awaits the phase of the barrier to advance from the given phase
+     * value, throwing {@code InterruptedException} if interrupted while
+     * waiting, or returning immediately if the current phase of the
+     * barrier is not equal to the given phase value or this barrier
+     * is terminated.
      *
      * @param phase the phase on entry to this method
-     * @return the phase on exit from this method
+     * @return the current barrier phase number upon exit of
+     * this method, or a negative value if terminated or
+     * argument is negative
      * @throws InterruptedException if thread interrupted while waiting
      */
     public int awaitAdvanceInterruptibly(int phase)
@@ -579,12 +584,20 @@ public class Phaser {
     }
 
     /**
-     * Awaits the phase of the barrier to advance from the given value
-     * or the given timeout elapses, or returns immediately if
-     * argument is negative or this barrier is terminated.
+     * Awaits the phase of the barrier to advance from the given phase
+     * value or the given timeout to elapse, throwing
+     * {@code InterruptedException} if interrupted while waiting, or
+     * returning immediately if the current phase of the barrier is not
+     * equal to the given phase value or this barrier is terminated.
      *
      * @param phase the phase on entry to this method
-     * @return the phase on exit from this method
+     * @param timeout how long to wait before giving up, in units of
+     *        {@code unit}
+     * @param unit a {@code TimeUnit} determining how to interpret the
+     *        {@code timeout} parameter
+     * @return the current barrier phase number upon exit of
+     * this method, or a negative value if terminated or
+     * argument is negative
      * @throws InterruptedException if thread interrupted while waiting
      * @throws TimeoutException if timed out while waiting
      */
@@ -713,7 +726,7 @@ public class Phaser {
      * only sensible to do so in designs where all parties register
      * before any arrive, and all {@link #awaitAdvance} at each phase.
      * Otherwise, you cannot ensure lack of interference from other
-     * parties during the the invocation of this method.
+     * parties during the invocation of this method.
      *
      * @param phase the phase number on entering the barrier
      * @param registeredParties the current number of registered parties