[ViewVC] Diff of: jsr166/jsr166/src/test/tck/StampedLockTest.java

Comparing jsr166/src/test/tck/StampedLockTest.java (file contents):
Revision 1.36 by jsr166, Mon May 29 19:15:03 2017 UTC vs.
Revision 1.42 by jsr166, Mon Nov 27 23:38:11 2017 UTC

+import static java.util.concurrent.TimeUnit.DAYS;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
-<
+import static java.util.concurrent.TimeUnit.SECONDS;
->
->
+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;
+        long s = lock.readLock();
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
-<
+                threadAssertEquals(0L, lock.tryWriteLock());
->
+                assertEquals(0L, lock.tryWriteLock());
+            }});
+        awaitTermination(t);
+        assertUnlocked(lock);
-+
-+
+    /**
-+
+     * Stamped locks are not reentrant.
-+
+     */
-+
+    public void testNonReentrant() throws InterruptedException {
-+
+        final StampedLock lock = new StampedLock();
-+
+        long stamp;
-+
-+
+        stamp = lock.writeLock();
-+
+        assertValid(lock, stamp);
-+
+        assertEquals(0L, lock.tryWriteLock(0L, DAYS));
-+
+        assertEquals(0L, lock.tryReadLock(0L, DAYS));
-+
+        assertValid(lock, stamp);
-+
+        lock.unlockWrite(stamp);
-+
-+
+        stamp = lock.tryWriteLock(1L, DAYS);
-+
+        assertEquals(0L, lock.tryWriteLock(0L, DAYS));
-+
+        assertValid(lock, stamp);
-+
+        lock.unlockWrite(stamp);
-+
-+
+        stamp = lock.readLock();
-+
+        assertEquals(0L, lock.tryWriteLock(0L, DAYS));
-+
+        assertValid(lock, stamp);
-+
+        lock.unlockRead(stamp);
-+
+    }
-+
-+
+    /**
-+
+     * """StampedLocks have no notion of ownership. Locks acquired in
-+
+     * one thread can be released or converted in another."""
-+
+     */
-+
+    public void testNoOwnership() throws Throwable {
-+
+        ArrayList<Future<?>> futures = new ArrayList<>();
-+
+        for (Function<StampedLock, Long> writeLocker : writeLockers())
-+
+        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
-+
+            StampedLock lock = new StampedLock();
-+
+            long stamp = writeLocker.apply(lock);
-+
+            futures.add(cachedThreadPool.submit(new CheckedRunnable() {
-+
+                public void realRun() {
-+
+                    writeUnlocker.accept(lock, stamp);
-+
+                    assertUnlocked(lock);
-+
+                    assertFalse(lock.validate(stamp));
-+
+                }}));
-+
+        }
-+
+        for (Future<?> future : futures)
-+
+            assertNull(future.get());
-+
+    }
-+
-+
+    /** Tries out sample usage code from StampedLock javadoc. */
-+
+    public void testSampleUsage() throws Throwable {
-+
+        class Point {
-+
+            private double x, y;
-+
+            private final StampedLock sl = new StampedLock();
-+
-+
+            void move(double deltaX, double deltaY) { // an exclusively locked method
-+
+                long stamp = sl.writeLock();
-+
+                try {
-+
+                    x += deltaX;
-+
+                    y += deltaY;
-+
+                } finally {
-+
+                    sl.unlockWrite(stamp);
-+
+                }
-+
+            }
-+
-+
+            double distanceFromOrigin() { // A read-only method
-+
+                double currentX, currentY;
-+
+                long stamp = sl.tryOptimisticRead();
-+
+                do {
-+
+                    if (stamp == 0L)
-+
+                        stamp = sl.readLock();
-+
+                    try {
-+
+                        // possibly racy reads
-+
+                        currentX = x;
-+
+                        currentY = y;
-+
+                    } finally {
-+
+                        stamp = sl.tryConvertToOptimisticRead(stamp);
-+
+                    }
-+
+                } 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);
-+
+            }
-+
+        }
-+
+    }
-+

Diff Legend

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

Comparing jsr166/src/test/tck/StampedLockTest.java (file contents): Revision 1.36 by jsr166, Mon May 29 19:15:03 2017 UTC vs. Revision 1.42 by jsr166, Mon Nov 27 23:38:11 2017 UTC

Diff Legend

Comparing jsr166/src/test/tck/StampedLockTest.java (file contents):
Revision 1.36 by jsr166, Mon May 29 19:15:03 2017 UTC vs.
Revision 1.42 by jsr166, Mon Nov 27 23:38:11 2017 UTC