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

Comparing jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java (file contents):
Revision 1.58 by jsr166, Fri Sep 29 19:34:37 2017 UTC vs.
Revision 1.70 by jsr166, Thu Aug 15 14:56:32 2019 UTC

+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
-+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.concurrent.locks.AbstractQueuedSynchronizer;
+import java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject;
-–
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+        long startTime = System.nanoTime();
+        while (!sync.isQueued(t)) {
+            if (millisElapsedSince(startTime) > LONG_DELAY_MS)
-<
+                throw new AssertionFailedError("timed out");
->
+                throw new AssertionError("timed out");
+            Thread.yield();
+        assertTrue(t.isAlive());
+            assertTrue(c.await(timeoutMillis, MILLISECONDS));
+            break;
+        case awaitNanos:
-<
+            long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
-<
+            long nanosRemaining = c.awaitNanos(nanosTimeout);
->
+            long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
->
+            long nanosRemaining = c.awaitNanos(timeoutNanos);
+            assertTrue(nanosRemaining > 0);
+            break;
+        case awaitUntil:
+                break;
+            case awaitNanos:
+                startTime = System.nanoTime();
-<
+                long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
-<
+                long nanosRemaining = c.awaitNanos(nanosTimeout);
->
+                long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
->
+                long nanosRemaining = c.awaitNanos(timeoutNanos);
+                assertTrue(nanosRemaining <= 0);
+                assertTrue(nanosRemaining > -MILLISECONDS.toNanos(LONG_DELAY_MS));
+                assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
+        sync.release();
-+
+    /**
-+
+     * JDK-8191483: AbstractQueuedSynchronizer cancel/cancel race
-+
+     * ant -Djsr166.tckTestClass=AbstractQueuedSynchronizerTest -Djsr166.methodFilter=testCancelCancelRace -Djsr166.runsPerTest=100 tck
-+
+     */
-+
+    public void testCancelCancelRace() throws InterruptedException {
-+
+        class Sync extends AbstractQueuedSynchronizer {
-+
+            protected boolean tryAcquire(int acquires) {
-+
+                return !hasQueuedPredecessors() && compareAndSetState(0, 1);
-+
+            }
-+
+            protected boolean tryRelease(int releases) {
-+
+                return compareAndSetState(1, 0);
-+
+            }
-+
+        }
-+
-+
+        Sync s = new Sync();
-+
+        s.acquire(1);           // acquire to force other threads to enqueue
-+
-+
+        // try to trigger double cancel race with two background threads
-+
+        ArrayList<Thread> threads = new ArrayList<>();
-+
+        Runnable failedAcquire = () -> {
-+
+            try {
-+
+                s.acquireInterruptibly(1);
-+
+                shouldThrow();
-+
+            } catch (InterruptedException success) {}
-+
+        };
-+
+        for (int i = 0; i < 2; i++) {
-+
+            Thread thread = new Thread(failedAcquire);
-+
+            thread.start();
-+
+            threads.add(thread);
-+
+        }
-+
+        Thread.sleep(100);
-+
+        for (Thread thread : threads) thread.interrupt();
-+
+        for (Thread thread : threads) awaitTermination(thread);
-+
-+
+        s.release(1);
-+
-+
+        // no one holds lock now, we should be able to acquire
-+
+        if (!s.tryAcquire(1))
-+
+            throw new RuntimeException(
-+
+                String.format(
-+
+                    "Broken: hasQueuedPredecessors=%s hasQueuedThreads=%s queueLength=%d firstQueuedThread=%s",
-+
+                    s.hasQueuedPredecessors(),
-+
+                    s.hasQueuedThreads(),
-+
+                    s.getQueueLength(),
-+
+                    s.getFirstQueuedThread()));
-+
+    }
-+
-+
+    /**
-+
+     * Tests scenario for
-+
+     * JDK-8191937: Lost interrupt in AbstractQueuedSynchronizer when tryAcquire methods throw
-+
+     * ant -Djsr166.tckTestClass=AbstractQueuedSynchronizerTest -Djsr166.methodFilter=testInterruptedFailingAcquire -Djsr166.runsPerTest=10000 tck
-+
+     */
-+
+    public void testInterruptedFailingAcquire() throws Throwable {
-+
+        final RuntimeException ex = new RuntimeException();
-+
-+
+        // A synchronizer only offering a choice of failure modes
-+
+        class Sync extends AbstractQueuedSynchronizer {
-+
+            volatile boolean pleaseThrow;
-+
+            @Override protected boolean tryAcquire(int ignored) {
-+
+                if (pleaseThrow) throw ex;
-+
+                return false;
-+
+            }
-+
+            @Override protected int tryAcquireShared(int ignored) {
-+
+                if (pleaseThrow) throw ex;
-+
+                return -1;
-+
+            }
-+
+            @Override protected boolean tryRelease(int ignored) {
-+
+                return true;
-+
+            }
-+
+            @Override protected boolean tryReleaseShared(int ignored) {
-+
+                return true;
-+
+            }
-+
+        }
-+
-+
+        final Sync s = new Sync();
-+
+        final Action[] uninterruptibleAcquireMethods = {
-+
+            () -> s.acquire(1),
-+
+            () -> s.acquireShared(1),
-+
+            // TODO: test interruptible acquire methods
-+
+        };
-+
+        final Action[] releaseMethods = {
-+
+            () -> s.release(1),
-+
+            () -> s.releaseShared(1),
-+
+        };
-+
+        final Action acquireMethod
-+
+            = chooseRandomly(uninterruptibleAcquireMethods);
-+
+        final Action releaseMethod
-+
+            = chooseRandomly(releaseMethods);
-+
-+
+        // From os_posix.cpp:
-+
+        //
-+
+        // NOTE that since there is no "lock" around the interrupt and
-+
+        // is_interrupted operations, there is the possibility that the
-+
+        // interrupted flag (in osThread) will be "false" but that the
-+
+        // low-level events will be in the signaled state. This is
-+
+        // intentional. The effect of this is that Object.wait() and
-+
+        // LockSupport.park() will appear to have a spurious wakeup, which
-+
+        // is allowed and not harmful, and the possibility is so rare that
-+
+        // it is not worth the added complexity to add yet another lock.
-+
+        final Thread thread = newStartedThread(new CheckedRunnable() {
-+
+            public void realRun() {
-+
+                try {
-+
+                    acquireMethod.run();
-+
+                    shouldThrow();
-+
+                } catch (Throwable t) {
-+
+                    assertSame(ex, t);
-+
+                    awaitInterrupted();
-+
+                }
-+
+            }});
-+
+        for (long startTime = 0L;; ) {
-+
+            waitForThreadToEnterWaitState(thread);
-+
+            if (s.getFirstQueuedThread() == thread
-+
+                && s.hasQueuedPredecessors()
-+
+                && s.hasQueuedThreads()
-+
+                && s.getQueueLength() == 1)
-+
+                break;
-+
+            if (startTime == 0L)
-+
+                startTime = System.nanoTime();
-+
+            else if (millisElapsedSince(startTime) > LONG_DELAY_MS)
-+
+                fail("timed out waiting for AQS state: "
-+
+                     + "thread state=" + thread.getState()
-+
+                     + ", queued threads=" + s.getQueuedThreads());
-+
+            Thread.yield();
-+
+        }
-+
-+
+        s.pleaseThrow = true;
-+
+        // release and interrupt, in random order
-+
+        if (randomBoolean()) {
-+
+            thread.interrupt();
-+
+            releaseMethod.run();
-+
+        } else {
-+
+            releaseMethod.run();
-+
+            thread.interrupt();
-+
+        }
-+
+        awaitTermination(thread);
-+
-+
+        assertNull(s.getFirstQueuedThread());
-+
+        assertFalse(s.hasQueuedPredecessors());
-+
+        assertFalse(s.hasQueuedThreads());
-+
+        assertEquals(0, s.getQueueLength());
-+
+        assertTrue(s.getQueuedThreads().isEmpty());
-+
+    }
-+

Diff Legend

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

Comparing jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java (file contents): Revision 1.58 by jsr166, Fri Sep 29 19:34:37 2017 UTC vs. Revision 1.70 by jsr166, Thu Aug 15 14:56:32 2019 UTC

Diff Legend

Comparing jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java (file contents):
Revision 1.58 by jsr166, Fri Sep 29 19:34:37 2017 UTC vs.
Revision 1.70 by jsr166, Thu Aug 15 14:56:32 2019 UTC