From dc895e391192d28236e876fb592fdaabedacdd74 Mon Sep 17 00:00:00 2001 From: Doug Lea Date: Fri, 13 Oct 2017 18:29:21 -0700 Subject: [PATCH] 8187941: Add StampedLock stamp inspection methods Reviewed-by: martin, psandoz --- .../util/concurrent/locks/StampedLock.java | 149 ++++++++++++++++-- .../util/concurrent/tck/StampedLockTest.java | 109 +++++++++++++ 2 files changed, 243 insertions(+), 15 deletions(-) diff --git a/src/java.base/share/classes/java/util/concurrent/locks/StampedLock.java b/src/java.base/share/classes/java/util/concurrent/locks/StampedLock.java index 0ff5770391c..36a8c5a9849 100644 --- a/src/java.base/share/classes/java/util/concurrent/locks/StampedLock.java +++ b/src/java.base/share/classes/java/util/concurrent/locks/StampedLock.java @@ -140,7 +140,8 @@ import jdk.internal.vm.annotation.ReservedStackAccess; * private double x, y; * private final StampedLock sl = new StampedLock(); * - * void move(double deltaX, double deltaY) { // an exclusively locked method + * // an exclusively locked method + * void move(double deltaX, double deltaY) { * long stamp = sl.writeLock(); * try { * x += deltaX; @@ -150,25 +151,57 @@ import jdk.internal.vm.annotation.ReservedStackAccess; * } * } * - * double distanceFromOrigin() { // A read-only method - * double currentX, currentY; + * // a read-only method + * // upgrade from optimistic read to read lock + * double distanceFromOrigin() { * long stamp = sl.tryOptimisticRead(); - * do { - * if (stamp == 0L) - * stamp = sl.readLock(); - * try { + * try { + * retryHoldingLock: for (;; stamp = sl.readLock()) { + * if (stamp == 0L) + * continue retryHoldingLock; * // possibly racy reads - * currentX = x; - * currentY = y; - * } finally { - * stamp = sl.tryConvertToOptimisticRead(stamp); + * double currentX = x; + * double currentY = y; + * if (!sl.validate(stamp)) + * continue retryHoldingLock; + * return Math.hypot(currentX, currentY); * } - * } while (stamp == 0); - * return Math.hypot(currentX, currentY); + * } finally { + * if (StampedLock.isReadLockStamp(stamp)) + * sl.unlockRead(stamp); + * } * } * - * void moveIfAtOrigin(double newX, double newY) { // upgrade - * // Could instead start with optimistic, not read mode + * // upgrade from optimistic read to write lock + * void moveIfAtOrigin(double newX, double newY) { + * long stamp = sl.tryOptimisticRead(); + * try { + * retryHoldingLock: for (;; stamp = sl.writeLock()) { + * if (stamp == 0L) + * continue retryHoldingLock; + * // possibly racy reads + * double currentX = x; + * double currentY = y; + * if (!sl.validate(stamp)) + * continue retryHoldingLock; + * if (currentX != 0.0 || currentY != 0.0) + * break; + * stamp = sl.tryConvertToWriteLock(stamp); + * if (stamp == 0L) + * continue retryHoldingLock; + * // exclusive access + * x = newX; + * y = newY; + * return; + * } + * } finally { + * if (StampedLock.isWriteLockStamp(stamp)) + * sl.unlockWrite(stamp); + * } + * } + * + * // Upgrade read lock to write lock + * void moveIfAtOrigin(double newX, double newY) { * long stamp = sl.readLock(); * try { * while (x == 0.0 && y == 0.0) { @@ -881,6 +914,92 @@ public class StampedLock implements java.io.Serializable { return (state & RBITS) != 0L; } + /** + * Tells whether a stamp represents holding a lock exclusively. + * This method may be useful in conjunction with + * {@link #tryConvertToWriteLock}, for example: 
 {@code
+     * long stamp = sl.tryOptimisticRead();
+     * try {
+     *   ...
+     *   stamp = sl.tryConvertToWriteLock(stamp);
+     *   ...
+     * } finally {
+     *   if (StampedLock.isWriteLockStamp(stamp))
+     *     sl.unlockWrite(stamp);
+     * }}
+ * + * @param stamp a stamp returned by a previous StampedLock operation + * @return {@code true} if the stamp was returned by a successful + * write-lock operation + * @since 10 + */ + public static boolean isWriteLockStamp(long stamp) { + return (stamp & ABITS) == WBIT; + } + + /** + * Tells whether a stamp represents holding a lock non-exclusively. + * This method may be useful in conjunction with + * {@link #tryConvertToReadLock}, for example: 
 {@code
+     * long stamp = sl.tryOptimisticRead();
+     * try {
+     *   ...
+     *   stamp = sl.tryConvertToReadLock(stamp);
+     *   ...
+     * } finally {
+     *   if (StampedLock.isReadLockStamp(stamp))
+     *     sl.unlockRead(stamp);
+     * }}
+ * + * @param stamp a stamp returned by a previous StampedLock operation + * @return {@code true} if the stamp was returned by a successful + * read-lock operation + * @since 10 + */ + public static boolean isReadLockStamp(long stamp) { + return (stamp & RBITS) != 0L; + } + + /** + * Tells whether a stamp represents holding a lock. + * This method may be useful in conjunction with + * {@link #tryConvertToReadLock} and {@link #tryConvertToWriteLock}, + * for example: 
 {@code
+     * long stamp = sl.tryOptimisticRead();
+     * try {
+     *   ...
+     *   stamp = sl.tryConvertToReadLock(stamp);
+     *   ...
+     *   stamp = sl.tryConvertToWriteLock(stamp);
+     *   ...
+     * } finally {
+     *   if (StampedLock.isLockStamp(stamp))
+     *     sl.unlock(stamp);
+     * }}
+ * + * @param stamp a stamp returned by a previous StampedLock operation + * @return {@code true} if the stamp was returned by a successful + * read-lock or write-lock operation + * @since 10 + */ + public static boolean isLockStamp(long stamp) { + return (stamp & ABITS) != 0L; + } + + /** + * Tells whether a stamp represents a successful optimistic read. + * + * @param stamp a stamp returned by a previous StampedLock operation + * @return {@code true} if the stamp was returned by a successful + * optimistic read operation, that is, a non-zero return from + * {@link #tryOptimisticRead()} or + * {@link #tryConvertToOptimisticRead(long)} + * @since 10 + */ + public static boolean isOptimisticReadStamp(long stamp) { + return (stamp & ABITS) == 0L && stamp != 0L; + } + /** * Queries the number of read locks held for this lock. This * method is designed for use in monitoring system state, not for diff --git a/test/jdk/java/util/concurrent/tck/StampedLockTest.java b/test/jdk/java/util/concurrent/tck/StampedLockTest.java index 305bfdb5380..e415d470c99 100644 --- a/test/jdk/java/util/concurrent/tck/StampedLockTest.java +++ b/test/jdk/java/util/concurrent/tck/StampedLockTest.java @@ -35,6 +35,11 @@ import static java.util.concurrent.TimeUnit.DAYS; import static java.util.concurrent.TimeUnit.MILLISECONDS; +import static java.util.concurrent.locks.StampedLock.isLockStamp; +import static java.util.concurrent.locks.StampedLock.isOptimisticReadStamp; +import static java.util.concurrent.locks.StampedLock.isReadLockStamp; +import static java.util.concurrent.locks.StampedLock.isWriteLockStamp; + import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; @@ -1286,11 +1291,115 @@ public class StampedLockTest extends JSR166TestCase { } while (stamp == 0); return Math.hypot(currentX, currentY); } + + double distanceFromOrigin2() { + long stamp = sl.tryOptimisticRead(); + try { + retryHoldingLock: + for (;; stamp = sl.readLock()) { + if (stamp == 0L) + continue retryHoldingLock; + // possibly racy reads + double currentX = x; + double currentY = y; + if (!sl.validate(stamp)) + continue retryHoldingLock; + return Math.hypot(currentX, currentY); + } + } finally { + if (StampedLock.isReadLockStamp(stamp)) + sl.unlockRead(stamp); + } + } + + void moveIfAtOrigin(double newX, double newY) { + long stamp = sl.readLock(); + try { + while (x == 0.0 && y == 0.0) { + long ws = sl.tryConvertToWriteLock(stamp); + if (ws != 0L) { + stamp = ws; + x = newX; + y = newY; + return; + } + else { + sl.unlockRead(stamp); + stamp = sl.writeLock(); + } + } + } finally { + sl.unlock(stamp); + } + } } Point p = new Point(); p.move(3.0, 4.0); assertEquals(5.0, p.distanceFromOrigin()); + p.moveIfAtOrigin(5.0, 12.0); + assertEquals(5.0, p.distanceFromOrigin2()); + } + + /** + * Stamp inspection methods work as expected, and do not inspect + * the state of the lock itself. + */ + public void testStampStateInspectionMethods() { + StampedLock lock = new StampedLock(); + + assertFalse(isWriteLockStamp(0L)); + assertFalse(isReadLockStamp(0L)); + assertFalse(isLockStamp(0L)); + assertFalse(isOptimisticReadStamp(0L)); + + { + long stamp = lock.writeLock(); + for (int i = 0; i < 2; i++) { + assertTrue(isWriteLockStamp(stamp)); + assertFalse(isReadLockStamp(stamp)); + assertTrue(isLockStamp(stamp)); + assertFalse(isOptimisticReadStamp(stamp)); + if (i == 0) + lock.unlockWrite(stamp); + } + } + + { + long stamp = lock.readLock(); + for (int i = 0; i < 2; i++) { + assertFalse(isWriteLockStamp(stamp)); + assertTrue(isReadLockStamp(stamp)); + assertTrue(isLockStamp(stamp)); + assertFalse(isOptimisticReadStamp(stamp)); + if (i == 0) + lock.unlockRead(stamp); + } + } + + { + long optimisticStamp = lock.tryOptimisticRead(); + long readStamp = lock.tryConvertToReadLock(optimisticStamp); + long writeStamp = lock.tryConvertToWriteLock(readStamp); + for (int i = 0; i < 2; i++) { + assertFalse(isWriteLockStamp(optimisticStamp)); + assertFalse(isReadLockStamp(optimisticStamp)); + assertFalse(isLockStamp(optimisticStamp)); + assertTrue(isOptimisticReadStamp(optimisticStamp)); + + assertFalse(isWriteLockStamp(readStamp)); + assertTrue(isReadLockStamp(readStamp)); + assertTrue(isLockStamp(readStamp)); + assertFalse(isOptimisticReadStamp(readStamp)); + + assertTrue(isWriteLockStamp(writeStamp)); + assertFalse(isReadLockStamp(writeStamp)); + assertTrue(isLockStamp(writeStamp)); + assertFalse(isOptimisticReadStamp(writeStamp)); + if (i == 0) + lock.unlockWrite(writeStamp); + } + } } }