ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/AbstractQueuedLongSynchronizerTest.java

Comparing jsr166/src/test/tck/AbstractQueuedLongSynchronizerTest.java (file contents):
Revision 1.31 by jsr166, Wed Dec 31 20:34:16 2014 UTC vs.
Revision 1.50 by jsr166, Thu Aug 15 14:56:32 2019 UTC

#	Line 15 | Line 15 | import java.util.HashSet;
15		import java.util.concurrent.locks.AbstractQueuedLongSynchronizer;
16		import java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject;
17
18	–	import junit.framework.AssertionFailedError;
18		import junit.framework.Test;
19		import junit.framework.TestSuite;
20
21	+	@SuppressWarnings("WaitNotInLoop") // we implement spurious-wakeup freedom
22		public class AbstractQueuedLongSynchronizerTest extends JSR166TestCase {
23		public static void main(String[] args) {
24	<	junit.textui.TestRunner.run(suite());
24	>	main(suite(), args);
25		}
26		public static Test suite() {
27		return new TestSuite(AbstractQueuedLongSynchronizerTest.class);
#	Line 30 | Line 30 | public class AbstractQueuedLongSynchroni
30		/**
31		* A simple mutex class, adapted from the class javadoc.  Exclusive
32		* acquire tests exercise this as a sample user extension.
33	+	*
34	+	* Unlike the javadoc sample, we don't track owner thread via
35	+	* AbstractOwnableSynchronizer methods.
36		*/
37		static class Mutex extends AbstractQueuedLongSynchronizer {
38		/** An eccentric value > 32 bits for locked synchronizer state. */
#	Line 37 | Line 40 | public class AbstractQueuedLongSynchroni
40
41		static final long UNLOCKED = 0;
42
43	<	public boolean isHeldExclusively() {
43	>	/** Owner thread is untracked, so this is really just isLocked(). */
44	>	@Override public boolean isHeldExclusively() {
45		long state = getState();
46		assertTrue(state == UNLOCKED || state == LOCKED);
47		return state == LOCKED;
48		}
49
50	<	public boolean tryAcquire(long acquires) {
50	>	@Override protected boolean tryAcquire(long acquires) {
51		assertEquals(LOCKED, acquires);
52		return compareAndSetState(UNLOCKED, LOCKED);
53		}
54
55	<	public boolean tryRelease(long releases) {
55	>	@Override protected boolean tryRelease(long releases) {
56		if (getState() != LOCKED) throw new IllegalMonitorStateException();
57		setState(UNLOCKED);
58		return true;
#	Line 78 | Line 82 | public class AbstractQueuedLongSynchroni
82		release(LOCKED);
83		}
84
85	+	/** Faux-Implements Lock.newCondition(). */
86		public ConditionObject newCondition() {
87		return new ConditionObject();
88		}
89		}
90
91		/**
92	<	* A simple latch class, to test shared mode.
92	>	* A minimal latch class, to test shared mode.
93		*/
94		static class BooleanLatch extends AbstractQueuedLongSynchronizer {
95		public boolean isSignalled() { return getState() != 0; }
#	Line 94 | Line 99 | public class AbstractQueuedLongSynchroni
99		}
100
101		public boolean tryReleaseShared(long ignore) {
102	<	setState(1 << 62);
102	>	setState(1L << 62);
103		return true;
104		}
105		}
#	Line 134 | Line 139 | public class AbstractQueuedLongSynchroni
139		long startTime = System.nanoTime();
140		while (!sync.isQueued(t)) {
141		if (millisElapsedSince(startTime) > LONG_DELAY_MS)
142	<	throw new AssertionFailedError("timed out");
142	>	throw new AssertionError("timed out");
143		Thread.yield();
144		}
145		assertTrue(t.isAlive());
#	Line 218 | Line 223 | public class AbstractQueuedLongSynchroni
223		assertTrue(c.await(timeoutMillis, MILLISECONDS));
224		break;
225		case awaitNanos:
226	<	long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
227	<	long nanosRemaining = c.awaitNanos(nanosTimeout);
226	>	long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
227	>	long nanosRemaining = c.awaitNanos(timeoutNanos);
228		assertTrue(nanosRemaining > 0);
229		break;
230		case awaitUntil:
#	Line 235 | Line 240 | public class AbstractQueuedLongSynchroni
240		* default timeout duration).
241		*/
242		void assertAwaitTimesOut(ConditionObject c, AwaitMethod awaitMethod) {
243	<	long timeoutMillis = timeoutMillis();
244	<	long startTime = System.nanoTime();
243	>	final long timeoutMillis = timeoutMillis();
244	>	final long startTime;
245		try {
246		switch (awaitMethod) {
247		case awaitTimed:
248	+	startTime = System.nanoTime();
249		assertFalse(c.await(timeoutMillis, MILLISECONDS));
250	+	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
251		break;
252		case awaitNanos:
253	<	long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
254	<	long nanosRemaining = c.awaitNanos(nanosTimeout);
253	>	startTime = System.nanoTime();
254	>	long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
255	>	long nanosRemaining = c.awaitNanos(timeoutNanos);
256		assertTrue(nanosRemaining <= 0);
257	+	assertTrue(nanosRemaining > -MILLISECONDS.toNanos(LONG_DELAY_MS));
258	+	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
259		break;
260		case awaitUntil:
261	+	// We shouldn't assume that nanoTime and currentTimeMillis
262	+	// use the same time source, so don't use nanoTime here.
263	+	java.util.Date delayedDate = delayedDate(timeoutMillis);
264		assertFalse(c.awaitUntil(delayedDate(timeoutMillis)));
265	+	assertTrue(new java.util.Date().getTime() >= delayedDate.getTime());
266		break;
267		default:
268		throw new UnsupportedOperationException();
269		}
270		} catch (InterruptedException ie) { threadUnexpectedException(ie); }
257	–	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
271		}
272
273		/**
#	Line 957 | Line 970 | public class AbstractQueuedLongSynchroni
970		*/
971		public void testAwaitUninterruptibly() {
972		final Mutex sync = new Mutex();
973	<	final ConditionObject c = sync.newCondition();
973	>	final ConditionObject condition = sync.newCondition();
974		final BooleanLatch pleaseInterrupt = new BooleanLatch();
975		Thread t = newStartedThread(new CheckedRunnable() {
976		public void realRun() {
977		sync.acquire();
978		assertTrue(pleaseInterrupt.releaseShared(0));
979	<	c.awaitUninterruptibly();
979	>	condition.awaitUninterruptibly();
980		assertTrue(Thread.interrupted());
981	<	assertHasWaitersLocked(sync, c, NO_THREADS);
981	>	assertHasWaitersLocked(sync, condition, NO_THREADS);
982		sync.release();
983		}});
984
985		pleaseInterrupt.acquireShared(0);
986		sync.acquire();
987	<	assertHasWaitersLocked(sync, c, t);
987	>	assertHasWaitersLocked(sync, condition, t);
988		sync.release();
989		t.interrupt();
990	<	assertHasWaitersUnlocked(sync, c, t);
991	<	assertThreadStaysAlive(t);
990	>	assertHasWaitersUnlocked(sync, condition, t);
991	>	assertThreadBlocks(t, Thread.State.WAITING);
992		sync.acquire();
993	<	assertHasWaitersLocked(sync, c, t);
993	>	assertHasWaitersLocked(sync, condition, t);
994		assertHasExclusiveQueuedThreads(sync, NO_THREADS);
995	<	c.signal();
996	<	assertHasWaitersLocked(sync, c, NO_THREADS);
995	>	condition.signal();
996	>	assertHasWaitersLocked(sync, condition, NO_THREADS);
997		assertHasExclusiveQueuedThreads(sync, t);
998		sync.release();
999		awaitTermination(t);
#	Line 1123 | Line 1136 | public class AbstractQueuedLongSynchroni
1136
1137		waitForQueuedThread(l, t);
1138		assertFalse(l.isSignalled());
1139	<	assertThreadStaysAlive(t);
1139	>	assertThreadBlocks(t, Thread.State.WAITING);
1140		assertHasSharedQueuedThreads(l, t);
1141		assertTrue(l.releaseShared(0));
1142		assertTrue(l.isSignalled());
#	Line 1148 | Line 1161 | public class AbstractQueuedLongSynchroni
1161
1162		waitForQueuedThread(l, t);
1163		assertFalse(l.isSignalled());
1164	<	assertThreadStaysAlive(t);
1164	>	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1165		assertTrue(l.releaseShared(0));
1166		assertTrue(l.isSignalled());
1167		awaitTermination(t);
#	Line 1197 | Line 1210 | public class AbstractQueuedLongSynchroni
1210		public void testTryAcquireSharedNanos_Timeout() {
1211		final BooleanLatch l = new BooleanLatch();
1212		final BooleanLatch observedQueued = new BooleanLatch();
1200	–	final long timeoutMillis = timeoutMillis();
1213		Thread t = newStartedThread(new CheckedRunnable() {
1214		public void realRun() throws InterruptedException {
1215		assertFalse(l.isSignalled());
#	Line 1243 | Line 1255 | public class AbstractQueuedLongSynchroni
1255		sync.release();
1256		}
1257
1258	+	/**
1259	+	* Tests scenario for
1260	+	* JDK-8191937: Lost interrupt in AbstractQueuedSynchronizer when tryAcquire methods throw
1261	+	* ant -Djsr166.tckTestClass=AbstractQueuedLongSynchronizerTest -Djsr166.methodFilter=testInterruptedFailingAcquire -Djsr166.runsPerTest=10000 tck
1262	+	*/
1263	+	public void testInterruptedFailingAcquire() throws Throwable {
1264	+	final RuntimeException ex = new RuntimeException();
1265	+
1266	+	// A synchronizer only offering a choice of failure modes
1267	+	class Sync extends AbstractQueuedLongSynchronizer {
1268	+	volatile boolean pleaseThrow;
1269	+	@Override protected boolean tryAcquire(long ignored) {
1270	+	if (pleaseThrow) throw ex;
1271	+	return false;
1272	+	}
1273	+	@Override protected long tryAcquireShared(long ignored) {
1274	+	if (pleaseThrow) throw ex;
1275	+	return -1;
1276	+	}
1277	+	@Override protected boolean tryRelease(long ignored) {
1278	+	return true;
1279	+	}
1280	+	@Override protected boolean tryReleaseShared(long ignored) {
1281	+	return true;
1282	+	}
1283	+	}
1284	+
1285	+	final Sync s = new Sync();
1286	+	final Action[] uninterruptibleAcquireMethods = {
1287	+	() -> s.acquire(1),
1288	+	() -> s.acquireShared(1),
1289	+	// TODO: test interruptible acquire methods
1290	+	};
1291	+	final Action[] releaseMethods = {
1292	+	() -> s.release(1),
1293	+	() -> s.releaseShared(1),
1294	+	};
1295	+	final Action acquireMethod
1296	+	= chooseRandomly(uninterruptibleAcquireMethods);
1297	+	final Action releaseMethod
1298	+	= chooseRandomly(releaseMethods);
1299	+
1300	+	// From os_posix.cpp:
1301	+	//
1302	+	// NOTE that since there is no "lock" around the interrupt and
1303	+	// is_interrupted operations, there is the possibility that the
1304	+	// interrupted flag (in osThread) will be "false" but that the
1305	+	// low-level events will be in the signaled state. This is
1306	+	// intentional. The effect of this is that Object.wait() and
1307	+	// LockSupport.park() will appear to have a spurious wakeup, which
1308	+	// is allowed and not harmful, and the possibility is so rare that
1309	+	// it is not worth the added complexity to add yet another lock.
1310	+	final Thread thread = newStartedThread(new CheckedRunnable() {
1311	+	public void realRun() {
1312	+	try {
1313	+	acquireMethod.run();
1314	+	shouldThrow();
1315	+	} catch (Throwable t) {
1316	+	assertSame(ex, t);
1317	+	awaitInterrupted();
1318	+	}
1319	+	}});
1320	+	for (long startTime = 0L;; ) {
1321	+	waitForThreadToEnterWaitState(thread);
1322	+	if (s.getFirstQueuedThread() == thread
1323	+	&& s.hasQueuedPredecessors()
1324	+	&& s.hasQueuedThreads()
1325	+	&& s.getQueueLength() == 1)
1326	+	break;
1327	+	if (startTime == 0L)
1328	+	startTime = System.nanoTime();
1329	+	else if (millisElapsedSince(startTime) > LONG_DELAY_MS)
1330	+	fail("timed out waiting for AQS state: "
1331	+	+ "thread state=" + thread.getState()
1332	+	+ ", queued threads=" + s.getQueuedThreads());
1333	+	Thread.yield();
1334	+	}
1335	+
1336	+	s.pleaseThrow = true;
1337	+	// release and interrupt, in random order
1338	+	if (randomBoolean()) {
1339	+	thread.interrupt();
1340	+	releaseMethod.run();
1341	+	} else {
1342	+	releaseMethod.run();
1343	+	thread.interrupt();
1344	+	}
1345	+	awaitTermination(thread);
1346	+
1347	+	assertNull(s.getFirstQueuedThread());
1348	+	assertFalse(s.hasQueuedPredecessors());
1349	+	assertFalse(s.hasQueuedThreads());
1350	+	assertEquals(0, s.getQueueLength());
1351	+	assertTrue(s.getQueuedThreads().isEmpty());
1352	+	}
1353	+
1354		}

Diff Legend

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