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

Comparing jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java (file contents):
Revision 1.59 by jsr166, Mon Nov 27 03:25:42 2017 UTC vs.
Revision 1.71 by jsr166, Thu Aug 15 16:01:30 2019 UTC

# Line 16 | Line 16 | import java.util.HashSet;
16   import java.util.concurrent.locks.AbstractQueuedSynchronizer;
17   import java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject;
18  
19 – import junit.framework.AssertionFailedError;
19   import junit.framework.Test;
20   import junit.framework.TestSuite;
21  
# Line 144 | Line 143 | public class AbstractQueuedSynchronizerT
143          long startTime = System.nanoTime();
144          while (!sync.isQueued(t)) {
145              if (millisElapsedSince(startTime) > LONG_DELAY_MS)
146 <                throw new AssertionFailedError("timed out");
146 >                throw new AssertionError("timed out");
147              Thread.yield();
148          }
149          assertTrue(t.isAlive());
# Line 228 | Line 227 | public class AbstractQueuedSynchronizerT
227              assertTrue(c.await(timeoutMillis, MILLISECONDS));
228              break;
229          case awaitNanos:
230 <            long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
231 <            long nanosRemaining = c.awaitNanos(nanosTimeout);
230 >            long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
231 >            long nanosRemaining = c.awaitNanos(timeoutNanos);
232              assertTrue(nanosRemaining > 0);
233              break;
234          case awaitUntil:
# Line 256 | Line 255 | public class AbstractQueuedSynchronizerT
255                  break;
256              case awaitNanos:
257                  startTime = System.nanoTime();
258 <                long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
259 <                long nanosRemaining = c.awaitNanos(nanosTimeout);
258 >                long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
259 >                long nanosRemaining = c.awaitNanos(timeoutNanos);
260                  assertTrue(nanosRemaining <= 0);
261                  assertTrue(nanosRemaining > -MILLISECONDS.toNanos(LONG_DELAY_MS));
262                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
# Line 1261 | Line 1260 | public class AbstractQueuedSynchronizerT
1260      }
1261  
1262      /**
1264 –     * Disabled demo test for (unfixed as of 2017-11)
1263       * JDK-8191483: AbstractQueuedSynchronizer cancel/cancel race
1264       * ant -Djsr166.tckTestClass=AbstractQueuedSynchronizerTest -Djsr166.methodFilter=testCancelCancelRace -Djsr166.runsPerTest=100 tck
1265       */
1266 <    public void XXXXtestCancelCancelRace() throws InterruptedException {
1266 >    public void testCancelCancelRace() throws InterruptedException {
1267          class Sync extends AbstractQueuedSynchronizer {
1268 <            private static final long serialVersionUID = 1L;
1271 <
1272 <            public boolean tryAcquire(int acquires) {
1268 >            protected boolean tryAcquire(int acquires) {
1269                  return !hasQueuedPredecessors() && compareAndSetState(0, 1);
1270              }
1275 –
1271              protected boolean tryRelease(int releases) {
1272                  return compareAndSetState(1, 0);
1273              }
# Line 1282 | Line 1277 | public class AbstractQueuedSynchronizerT
1277          s.acquire(1);           // acquire to force other threads to enqueue
1278  
1279          // try to trigger double cancel race with two background threads
1280 <        ArrayList<Thread> ts = new ArrayList<>();
1280 >        ArrayList<Thread> threads = new ArrayList<>();
1281          Runnable failedAcquire = () -> {
1282              try {
1283                  s.acquireInterruptibly(1);
1284 <                throw new AssertionError();
1285 <            } catch (InterruptedException expected) {}
1284 >                shouldThrow();
1285 >            } catch (InterruptedException success) {}
1286          };
1287          for (int i = 0; i < 2; i++) {
1288 <            Thread t = new Thread(failedAcquire);
1289 <            t.start();
1290 <            ts.add(t);
1288 >            Thread thread = new Thread(failedAcquire);
1289 >            thread.start();
1290 >            threads.add(thread);
1291          }
1292          Thread.sleep(100);
1293 <        for (Thread t : ts) t.interrupt();
1294 <        for (Thread t : ts) t.join();
1293 >        for (Thread thread : threads) thread.interrupt();
1294 >        for (Thread thread : threads) awaitTermination(thread);
1295  
1296          s.release(1);
1297  
# Line 1311 | Line 1306 | public class AbstractQueuedSynchronizerT
1306                      s.getFirstQueuedThread()));
1307      }
1308  
1309 +    /**
1310 +     * Tests scenario for
1311 +     * JDK-8191937: Lost interrupt in AbstractQueuedSynchronizer when tryAcquire methods throw
1312 +     * ant -Djsr166.tckTestClass=AbstractQueuedSynchronizerTest -Djsr166.methodFilter=testInterruptedFailingAcquire -Djsr166.runsPerTest=10000 tck
1313 +     */
1314 +    public void testInterruptedFailingAcquire() throws Throwable {
1315 +        class PleaseThrow extends RuntimeException {}
1316 +        final PleaseThrow ex = new PleaseThrow();
1317 +
1318 +        // A synchronizer only offering a choice of failure modes
1319 +        class Sync extends AbstractQueuedSynchronizer {
1320 +            volatile boolean pleaseThrow;
1321 +            @Override protected boolean tryAcquire(int ignored) {
1322 +                if (pleaseThrow) throw ex;
1323 +                return false;
1324 +            }
1325 +            @Override protected int tryAcquireShared(int ignored) {
1326 +                if (pleaseThrow) throw ex;
1327 +                return -1;
1328 +            }
1329 +            @Override protected boolean tryRelease(int ignored) {
1330 +                return true;
1331 +            }
1332 +            @Override protected boolean tryReleaseShared(int ignored) {
1333 +                return true;
1334 +            }
1335 +        }
1336 +
1337 +        final Sync s = new Sync();
1338 +        final boolean acquireInterruptibly = randomBoolean();
1339 +        final Action[] uninterruptibleAcquireActions = {
1340 +            () -> s.acquire(1),
1341 +            () -> s.acquireShared(1),
1342 +        };
1343 +        final long nanosTimeout = MILLISECONDS.toNanos(2 * LONG_DELAY_MS);
1344 +        final Action[] interruptibleAcquireActions = {
1345 +            () -> s.acquireInterruptibly(1),
1346 +            () -> s.acquireSharedInterruptibly(1),
1347 +            () -> s.tryAcquireNanos(1, nanosTimeout),
1348 +            () -> s.tryAcquireSharedNanos(1, nanosTimeout),
1349 +        };
1350 +        final Action[] releaseActions = {
1351 +            () -> s.release(1),
1352 +            () -> s.releaseShared(1),
1353 +        };
1354 +        final Action acquireAction = acquireInterruptibly
1355 +            ? chooseRandomly(interruptibleAcquireActions)
1356 +            : chooseRandomly(uninterruptibleAcquireActions);
1357 +        final Action releaseAction
1358 +            = chooseRandomly(releaseActions);
1359 +
1360 +        // From os_posix.cpp:
1361 +        //
1362 +        // NOTE that since there is no "lock" around the interrupt and
1363 +        // is_interrupted operations, there is the possibility that the
1364 +        // interrupted flag (in osThread) will be "false" but that the
1365 +        // low-level events will be in the signaled state. This is
1366 +        // intentional. The effect of this is that Object.wait() and
1367 +        // LockSupport.park() will appear to have a spurious wakeup, which
1368 +        // is allowed and not harmful, and the possibility is so rare that
1369 +        // it is not worth the added complexity to add yet another lock.
1370 +        final Thread thread = newStartedThread(new CheckedRunnable() {
1371 +            public void realRun() throws Throwable {
1372 +                try {
1373 +                    acquireAction.run();
1374 +                    shouldThrow();
1375 +                } catch (InterruptedException possible) {
1376 +                    assertTrue(acquireInterruptibly);
1377 +                    assertFalse(Thread.interrupted());
1378 +                } catch (PleaseThrow possible) {
1379 +                    awaitInterrupted();
1380 +                }
1381 +            }});
1382 +        for (long startTime = 0L;; ) {
1383 +            waitForThreadToEnterWaitState(thread);
1384 +            if (s.getFirstQueuedThread() == thread
1385 +                && s.hasQueuedPredecessors()
1386 +                && s.hasQueuedThreads()
1387 +                && s.getQueueLength() == 1)
1388 +                break;
1389 +            if (startTime == 0L)
1390 +                startTime = System.nanoTime();
1391 +            else if (millisElapsedSince(startTime) > LONG_DELAY_MS)
1392 +                fail("timed out waiting for AQS state: "
1393 +                     + "thread state=" + thread.getState()
1394 +                     + ", queued threads=" + s.getQueuedThreads());
1395 +            Thread.yield();
1396 +        }
1397 +
1398 +        s.pleaseThrow = true;
1399 +        // release and interrupt, in random order
1400 +        if (randomBoolean()) {
1401 +            thread.interrupt();
1402 +            releaseAction.run();
1403 +        } else {
1404 +            releaseAction.run();
1405 +            thread.interrupt();
1406 +        }
1407 +        awaitTermination(thread);
1408 +
1409 +        assertNull(s.getFirstQueuedThread());
1410 +        assertFalse(s.hasQueuedPredecessors());
1411 +        assertFalse(s.hasQueuedThreads());
1412 +        assertEquals(0, s.getQueueLength());
1413 +        assertTrue(s.getQueuedThreads().isEmpty());
1414 +    }
1415 +
1416   }

Diff Legend

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