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

Comparing jsr166/src/jsr166e/StampedLock.java (file contents):
Revision 1.19 by dl, Mon Oct 15 12:12:42 2012 UTC vs.
Revision 1.24 by jsr166, Sun Nov 25 21:40:11 2012 UTC

# Line 63 | Line 63 | import java.util.concurrent.TimeUnit;
63   *
64   * <p>StampedLocks are designed for use as internal utilities in the
65   * development of thread-safe components. Their use relies on
66 < * knowledge of the internal properties of the the data, objects, and
66 > * knowledge of the internal properties of the data, objects, and
67   * methods they are protecting.  They are not reentrant, so locked
68   * bodies should not call other unknown methods that may try to
69   * re-acquire locks (although you may pass a stamp to other methods
# Line 125 | Line 125 | import java.util.concurrent.TimeUnit;
125   *   }
126   *
127   *   double distanceFromOriginV2() { // combines code paths
128 + *     double currentX = 0.0, currentY = 0.0;
129   *     for (long stamp = sl.tryOptimisticRead(); ; stamp = sl.readLock()) {
129 – *       double currentX = 0.0, currentY = 0.0;
130   *       try {
131   *         currentX = x;
132   *         currentY = y;
133   *       } finally {
134   *         if (sl.tryConvertToOptimisticRead(stamp) != 0L) // unlock or validate
135 < *           return Math.sqrt(currentX * currentX + currentY * currentY);
135 > *           break;
136   *       }
137   *     }
138 + *     return Math.sqrt(currentX * currentX + currentY * currentY);
139   *   }
140   *
141   *   void moveIfAtOrigin(double newX, double newY) { // upgrade
# Line 155 | Line 156 | import java.util.concurrent.TimeUnit;
156   *         }
157   *       }
158   *     } finally {
159 < *        sl.unlock(stamp);
159 > *       sl.unlock(stamp);
160   *     }
161   *   }
162   * }}</pre>
# Line 225 | Line 226 | public class StampedLock implements java
226       * threads.  Both await methods use a similar spin strategy: If
227       * the associated queue appears to be empty, then the thread
228       * spin-waits up to SPINS times (where each iteration decreases
229 <     * spin count with 50% probablility) before enqueing, and then, if
229 >     * spin count with 50% probability) before enqueing, and then, if
230       * it is the first thread to be enqueued, spins again up to SPINS
231       * times before blocking. If, upon wakening it fails to obtain
232       * lock, and is still (or becomes) the first waiting thread (which
# Line 994 | Line 995 | public class StampedLock implements java
995                          else if ((time = deadline - System.nanoTime()) <= 0L)
996                              return cancelWriter(node, false);
997                          if (node.prev == p && p.status == WAITING &&
998 <                            (p != whead || (state & WBIT) != 0L)) // recheck
998 >                            (p != whead || (state & ABITS) != 0L)) // recheck
999                              U.park(false, time);
1000                          if (interruptible && Thread.interrupted())
1001                              return cancelWriter(node, true);
# Line 1007 | Line 1008 | public class StampedLock implements java
1008      /**
1009       * If node non-null, forces cancel status and unsplices from queue
1010       * if possible. This is a variant of cancellation methods in
1011 <     * AbstractQueuedSynchronizer (see its detailed explanation in
1011 >     * AbstractQueuedSynchronizer (see its detailed explanation in AQS
1012       * internal documentation) that more conservatively wakes up other
1013 <     * threads that may have had their links changed so as to preserve
1013 >     * threads that may have had their links changed, so as to preserve
1014       * liveness in the main signalling methods.
1015       */
1016      private long cancelWriter(WNode node, boolean interrupted) {

Diff Legend

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