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.77 by jsr166, Mon Oct 17 23:37:19 2011 UTC vs.
Revision 1.81 by jsr166, Fri Jul 15 18:49:12 2016 UTC

# Line 17 | Line 17 | import java.util.concurrent.locks.LockSu
17   * {@link java.util.concurrent.CountDownLatch CountDownLatch}
18   * but supporting more flexible usage.
19   *
20 < * <p> <b>Registration.</b> Unlike the case for other barriers, the
20 > * <p><b>Registration.</b> Unlike the case for other barriers, the
21   * number of parties <em>registered</em> to synchronize on a phaser
22   * may vary over time.  Tasks may be registered at any time (using
23   * methods {@link #register}, {@link #bulkRegister}, or forms of
# Line 30 | Line 30 | import java.util.concurrent.locks.LockSu
30   * (However, you can introduce such bookkeeping by subclassing this
31   * class.)
32   *
33 < * <p> <b>Synchronization.</b> Like a {@code CyclicBarrier}, a {@code
33 > * <p><b>Synchronization.</b> Like a {@code CyclicBarrier}, a {@code
34   * Phaser} may be repeatedly awaited.  Method {@link
35   * #arriveAndAwaitAdvance} has effect analogous to {@link
36   * java.util.concurrent.CyclicBarrier#await CyclicBarrier.await}. Each
# Line 44 | Line 44 | import java.util.concurrent.locks.LockSu
44   *
45   * <ul>
46   *
47 < *   <li> <b>Arrival.</b> Methods {@link #arrive} and
47 > *   <li><b>Arrival.</b> Methods {@link #arrive} and
48   *       {@link #arriveAndDeregister} record arrival.  These methods
49   *       do not block, but return an associated <em>arrival phase
50   *       number</em>; that is, the phase number of the phaser to which
# Line 57 | Line 57 | import java.util.concurrent.locks.LockSu
57   *       flexible than, providing a barrier action to a {@code
58   *       CyclicBarrier}.
59   *
60 < *   <li> <b>Waiting.</b> Method {@link #awaitAdvance} requires an
60 > *   <li><b>Waiting.</b> Method {@link #awaitAdvance} requires an
61   *       argument indicating an arrival phase number, and returns when
62   *       the phaser advances to (or is already at) a different phase.
63   *       Unlike similar constructions using {@code CyclicBarrier},
# Line 74 | Line 74 | import java.util.concurrent.locks.LockSu
74   *
75   * </ul>
76   *
77 < * <p> <b>Termination.</b> A phaser may enter a <em>termination</em>
77 > * <p><b>Termination.</b> A phaser may enter a <em>termination</em>
78   * state, that may be checked using method {@link #isTerminated}. Upon
79   * termination, all synchronization methods immediately return without
80   * waiting for advance, as indicated by a negative return value.
# Line 89 | Line 89 | import java.util.concurrent.locks.LockSu
89   * also available to abruptly release waiting threads and allow them
90   * to terminate.
91   *
92 < * <p> <b>Tiering.</b> Phasers may be <em>tiered</em> (i.e.,
92 > * <p><b>Tiering.</b> Phasers may be <em>tiered</em> (i.e.,
93   * constructed in tree structures) to reduce contention. Phasers with
94   * large numbers of parties that would otherwise experience heavy
95   * synchronization contention costs may instead be set up so that
# Line 193 | Line 193 | import java.util.concurrent.locks.LockSu
193   *   phaser.arriveAndDeregister();
194   * }}</pre>
195   *
196 – *
196   * <p>To create a set of {@code n} tasks using a tree of phasers, you
197   * could use code of the following form, assuming a Task class with a
198   * constructor accepting a {@code Phaser} that it registers with upon
# Line 1142 | Line 1141 | public class Phaser {
1141      private static sun.misc.Unsafe getUnsafe() {
1142          try {
1143              return sun.misc.Unsafe.getUnsafe();
1144 <        } catch (SecurityException se) {
1145 <            try {
1146 <                return java.security.AccessController.doPrivileged
1147 <                    (new java.security
1148 <                     .PrivilegedExceptionAction<sun.misc.Unsafe>() {
1149 <                        public sun.misc.Unsafe run() throws Exception {
1150 <                            java.lang.reflect.Field f = sun.misc
1151 <                                .Unsafe.class.getDeclaredField("theUnsafe");
1152 <                            f.setAccessible(true);
1153 <                            return (sun.misc.Unsafe) f.get(null);
1154 <                        }});
1155 <            } catch (java.security.PrivilegedActionException e) {
1156 <                throw new RuntimeException("Could not initialize intrinsics",
1157 <                                           e.getCause());
1158 <            }
1144 >        } catch (SecurityException tryReflectionInstead) {}
1145 >        try {
1146 >            return java.security.AccessController.doPrivileged
1147 >            (new java.security.PrivilegedExceptionAction<sun.misc.Unsafe>() {
1148 >                public sun.misc.Unsafe run() throws Exception {
1149 >                    Class<sun.misc.Unsafe> k = sun.misc.Unsafe.class;
1150 >                    for (java.lang.reflect.Field f : k.getDeclaredFields()) {
1151 >                        f.setAccessible(true);
1152 >                        Object x = f.get(null);
1153 >                        if (k.isInstance(x))
1154 >                            return k.cast(x);
1155 >                    }
1156 >                    throw new NoSuchFieldError("the Unsafe");
1157 >                }});
1158 >        } catch (java.security.PrivilegedActionException e) {
1159 >            throw new RuntimeException("Could not initialize intrinsics",
1160 >                                       e.getCause());
1161          }
1162      }
1163   }

Diff Legend

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