ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/jsr166y/Phaser.java
(Generate patch)

Comparing jsr166/src/jsr166y/Phaser.java (file contents):
Revision 1.13 by jsr166, Mon Jul 20 22:40:09 2009 UTC vs.
Revision 1.14 by jsr166, Tue Jul 21 00:15:14 2009 UTC

# Line 234 | Line 234 | public class Phaser {
234      }
235  
236      /**
237 <     * Returns message string for bad bounds exceptions
237 >     * Returns message string for bad bounds exceptions.
238       */
239      private static String badBounds(int parties, int unarrived) {
240          return ("Attempt to set " + unarrived +
# Line 309 | Line 309 | public class Phaser {
309      /**
310       * Creates a new Phaser with the given numbers of registered
311       * unarrived parties, initial phase number 0, and no parent.
312 <     * @param parties the number of parties required to trip barrier.
312 >     *
313 >     * @param parties the number of parties required to trip barrier
314       * @throws IllegalArgumentException if parties less than zero
315 <     * or greater than the maximum number of parties supported.
315 >     * or greater than the maximum number of parties supported
316       */
317      public Phaser(int parties) {
318          this(null, parties);
# Line 322 | Line 323 | public class Phaser {
323       * initially registered parties. If parent is non-null this phaser
324       * is registered with the parent and its initial phase number is
325       * the same as that of parent phaser.
326 <     * @param parent the parent phaser.
326 >     *
327 >     * @param parent the parent phaser
328       */
329      public Phaser(Phaser parent) {
330          int phase = 0;
# Line 338 | Line 340 | public class Phaser {
340  
341      /**
342       * Creates a new Phaser with the given parent and numbers of
343 <     * registered unarrived parties. If parent is non-null this phaser
343 >     * registered unarrived parties. If parent is non-null, this phaser
344       * is registered with the parent and its initial phase number is
345       * the same as that of parent phaser.
346 <     * @param parent the parent phaser.
347 <     * @param parties the number of parties required to trip barrier.
346 >     *
347 >     * @param parent the parent phaser
348 >     * @param parties the number of parties required to trip barrier
349       * @throws IllegalArgumentException if parties less than zero
350 <     * or greater than the maximum number of parties supported.
350 >     * or greater than the maximum number of parties supported
351       */
352      public Phaser(Phaser parent, int parties) {
353          if (parties < 0 || parties > ushortMask)
# Line 362 | Line 365 | public class Phaser {
365  
366      /**
367       * Adds a new unarrived party to this phaser.
368 +     *
369       * @return the current barrier phase number upon registration
370       * @throws IllegalStateException if attempting to register more
371 <     * than the maximum supported number of parties.
371 >     * than the maximum supported number of parties
372       */
373      public int register() {
374          return doRegister(1);
# Line 372 | Line 376 | public class Phaser {
376  
377      /**
378       * Adds the given number of new unarrived parties to this phaser.
379 <     * @param parties the number of parties required to trip barrier.
379 >     *
380 >     * @param parties the number of parties required to trip barrier
381       * @return the current barrier phase number upon registration
382       * @throws IllegalStateException if attempting to register more
383 <     * than the maximum supported number of parties.
383 >     * than the maximum supported number of parties
384       */
385      public int bulkRegister(int parties) {
386          if (parties < 0)
# Line 411 | Line 416 | public class Phaser {
416       * in turn wait for others via {@link #awaitAdvance}).
417       *
418       * @return the barrier phase number upon entry to this method, or a
419 <     * negative value if terminated;
419 >     * negative value if terminated
420       * @throws IllegalStateException if not terminated and the number
421 <     * of unarrived parties would become negative.
421 >     * of unarrived parties would become negative
422       */
423      public int arrive() {
424          int phase;
# Line 463 | Line 468 | public class Phaser {
468       * zero parties, this phaser is also deregistered from its parent.
469       *
470       * @return the current barrier phase number upon entry to
471 <     * this method, or a negative value if terminated;
471 >     * this method, or a negative value if terminated
472       * @throws IllegalStateException if not terminated and the number
473 <     * of registered or unarrived parties would become negative.
473 >     * of registered or unarrived parties would become negative
474       */
475      public int arriveAndDeregister() {
476          // similar code to arrive, but too different to merge
# Line 516 | Line 521 | public class Phaser {
521       * to {@code awaitAdvance(arrive())}.  If you instead need to
522       * await with interruption of timeout, and/or deregister upon
523       * arrival, you can arrange them using analogous constructions.
524 +     *
525       * @return the phase on entry to this method
526       * @throws IllegalStateException if not terminated and the number
527 <     * of unarrived parties would become negative.
527 >     * of unarrived parties would become negative
528       */
529      public int arriveAndAwaitAdvance() {
530          return awaitAdvance(arrive());
# Line 528 | Line 534 | public class Phaser {
534       * Awaits the phase of the barrier to advance from the given
535       * value, or returns immediately if argument is negative or this
536       * barrier is terminated.
537 +     *
538       * @param phase the phase on entry to this method
539       * @return the phase on exit from this method
540       */
# Line 549 | Line 556 | public class Phaser {
556       * value, or returns immediately if argument is negative or this
557       * barrier is terminated, or throws InterruptedException if
558       * interrupted while waiting.
559 +     *
560       * @param phase the phase on entry to this method
561       * @return the phase on exit from this method
562       * @throws InterruptedException if thread interrupted while waiting
# Line 570 | Line 578 | public class Phaser {
578       * Awaits the phase of the barrier to advance from the given value
579       * or the given timeout elapses, or returns immediately if
580       * argument is negative or this barrier is terminated.
581 +     *
582       * @param phase the phase on entry to this method
583       * @return the phase on exit from this method
584       * @throws InterruptedException if thread interrupted while waiting
# Line 616 | Line 625 | public class Phaser {
625       * Returns the current phase number. The maximum phase number is
626       * {@code Integer.MAX_VALUE}, after which it restarts at
627       * zero. Upon termination, the phase number is negative.
628 +     *
629       * @return the phase number, or a negative value if terminated
630       */
631      public final int getPhase() {
# Line 624 | Line 634 | public class Phaser {
634  
635      /**
636       * Returns {@code true} if the current phase number equals the given phase.
637 +     *
638       * @param phase the phase
639       * @return {@code true} if the current phase number equals the given phase
640       */
# Line 633 | Line 644 | public class Phaser {
644  
645      /**
646       * Returns the number of parties registered at this barrier.
647 +     *
648       * @return the number of parties
649       */
650      public int getRegisteredParties() {
# Line 642 | Line 654 | public class Phaser {
654      /**
655       * Returns the number of parties that have arrived at the current
656       * phase of this barrier.
657 +     *
658       * @return the number of arrived parties
659       */
660      public int getArrivedParties() {
# Line 651 | Line 664 | public class Phaser {
664      /**
665       * Returns the number of registered parties that have not yet
666       * arrived at the current phase of this barrier.
667 +     *
668       * @return the number of unarrived parties
669       */
670      public int getUnarrivedParties() {
# Line 659 | Line 673 | public class Phaser {
673  
674      /**
675       * Returns the parent of this phaser, or null if none.
676 +     *
677       * @return the parent of this phaser, or null if none
678       */
679      public Phaser getParent() {
# Line 668 | Line 683 | public class Phaser {
683      /**
684       * Returns the root ancestor of this phaser, which is the same as
685       * this phaser if it has no parent.
686 +     *
687       * @return the root ancestor of this phaser
688       */
689      public Phaser getRoot() {
# Line 676 | Line 692 | public class Phaser {
692  
693      /**
694       * Returns {@code true} if this barrier has been terminated.
695 +     *
696       * @return {@code true} if this barrier has been terminated
697       */
698      public boolean isTerminated() {
# Line 799 | Line 816 | public class Phaser {
816      }
817  
818      /**
819 <     * Removes and signals waiting threads from wait queue
819 >     * Removes and signals waiting threads from wait queue.
820       */
821      private void releaseWaiters(int phase) {
822          AtomicReference<QNode> head = queueFor(phase);
# Line 811 | Line 828 | public class Phaser {
828      }
829  
830      /**
831 <     * Tries to enqueue given node in the appropriate wait queue
831 >     * Tries to enqueue given node in the appropriate wait queue.
832 >     *
833       * @return true if successful
834       */
835      private boolean tryEnqueue(QNode node) {
# Line 821 | Line 839 | public class Phaser {
839  
840      /**
841       * Enqueues node and waits unless aborted or signalled.
842 +     *
843       * @return current phase
844       */
845      private int untimedWait(int phase) {

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines