ViewVC Help

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

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

Comparing jsr166/src/test/tck/ReentrantLockTest.java (file contents):
Revision 1.38 by jsr166, Sat Oct 9 19:30:35 2010 UTC vs.
Revision 1.45 by jsr166, Sat May 7 19:03:26 2011 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		* Other contributors include Andrew Wright, Jeffrey Hayes,
6		* Pat Fisher, Mike Judd.
7		*/
#	Line 32 | Line 32 | public class ReentrantLockTest extends J
32		}
33		}
34
35	–
35		/**
36		* A runnable calling lockInterruptibly that expects to be
37		* interrupted
#	Line 50 | Line 49 | public class ReentrantLockTest extends J
49		*/
50		static class PublicReentrantLock extends ReentrantLock {
51		PublicReentrantLock() { super(); }
52	+	PublicReentrantLock(boolean fair) { super(fair); }
53	+	public Thread getOwner() {
54	+	return super.getOwner();
55	+	}
56		public Collection<Thread> getQueuedThreads() {
57		return super.getQueuedThreads();
58		}
#	Line 59 | Line 62 | public class ReentrantLockTest extends J
62		}
63
64		/**
65	<	* Constructor sets given fairness
65	>	* Releases write lock, checking that it had a hold count of 1.
66	>	*/
67	>	void releaseLock(PublicReentrantLock lock) {
68	>	assertLockedBy(lock, Thread.currentThread());
69	>	lock.unlock();
70	>	assertFalse(lock.isHeldByCurrentThread());
71	>	assertNotLocked(lock);
72	>	}
73	>
74	>	/**
75	>	* Spin-waits until lock.hasQueuedThread(t) becomes true.
76	>	*/
77	>	void waitForQueuedThread(PublicReentrantLock lock, Thread t) {
78	>	long startTime = System.nanoTime();
79	>	while (!lock.hasQueuedThread(t)) {
80	>	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
81	>	throw new AssertionError("timed out");
82	>	Thread.yield();
83	>	}
84	>	assertTrue(t.isAlive());
85	>	assertTrue(lock.getOwner() != t);
86	>	}
87	>
88	>	/**
89	>	* Checks that lock is not locked.
90	>	*/
91	>	void assertNotLocked(PublicReentrantLock lock) {
92	>	assertFalse(lock.isLocked());
93	>	assertFalse(lock.isHeldByCurrentThread());
94	>	assertNull(lock.getOwner());
95	>	assertEquals(0, lock.getHoldCount());
96	>	}
97	>
98	>	/**
99	>	* Checks that lock is locked by the given thread.
100	>	*/
101	>	void assertLockedBy(PublicReentrantLock lock, Thread t) {
102	>	assertTrue(lock.isLocked());
103	>	assertSame(t, lock.getOwner());
104	>	assertEquals(t == Thread.currentThread(),
105	>	lock.isHeldByCurrentThread());
106	>	assertEquals(t == Thread.currentThread(),
107	>	lock.getHoldCount() > 0);
108	>	}
109	>
110	>	/**
111	>	* Checks that condition c has no waiters.
112	>	*/
113	>	void assertHasNoWaiters(PublicReentrantLock lock, Condition c) {
114	>	assertHasWaiters(lock, c, new Thread[] {});
115	>	}
116	>
117	>	/**
118	>	* Checks that condition c has exactly the given waiter threads.
119	>	*/
120	>	void assertHasWaiters(PublicReentrantLock lock, Condition c,
121	>	Thread... threads) {
122	>	lock.lock();
123	>	assertEquals(threads.length > 0, lock.hasWaiters(c));
124	>	assertEquals(threads.length, lock.getWaitQueueLength(c));
125	>	assertEquals(threads.length == 0, lock.getWaitingThreads(c).isEmpty());
126	>	assertEquals(threads.length, lock.getWaitingThreads(c).size());
127	>	assertEquals(new HashSet<Thread>(lock.getWaitingThreads(c)),
128	>	new HashSet<Thread>(Arrays.asList(threads)));
129	>	lock.unlock();
130	>	}
131	>
132	>	/**
133	>	* Constructor sets given fairness, and is in unlocked state
134		*/
135		public void testConstructor() {
136	<	assertFalse(new ReentrantLock().isFair());
137	<	assertFalse(new ReentrantLock(false).isFair());
138	<	assertTrue(new ReentrantLock(true).isFair());
136	>	PublicReentrantLock lock;
137	>
138	>	lock = new PublicReentrantLock();
139	>	assertFalse(lock.isFair());
140	>	assertNotLocked(lock);
141	>
142	>	lock = new PublicReentrantLock(true);
143	>	assertTrue(lock.isFair());
144	>	assertNotLocked(lock);
145	>
146	>	lock = new PublicReentrantLock(false);
147	>	assertFalse(lock.isFair());
148	>	assertNotLocked(lock);
149		}
150
151		/**
152		* locking an unlocked lock succeeds
153		*/
154		public void testLock() {
155	<	ReentrantLock rl = new ReentrantLock();
156	<	rl.lock();
157	<	assertTrue(rl.isLocked());
158	<	rl.unlock();
78	<	assertFalse(rl.isLocked());
155	>	PublicReentrantLock lock = new PublicReentrantLock();
156	>	lock.lock();
157	>	assertLockedBy(lock, Thread.currentThread());
158	>	releaseLock(lock);
159		}
160
161		/**
162		* locking an unlocked fair lock succeeds
163		*/
164		public void testFairLock() {
165	<	ReentrantLock rl = new ReentrantLock(true);
166	<	rl.lock();
167	<	assertTrue(rl.isLocked());
168	<	rl.unlock();
165	>	PublicReentrantLock lock = new PublicReentrantLock(true);
166	>	lock.lock();
167	>	assertLockedBy(lock, Thread.currentThread());
168	>	releaseLock(lock);
169		}
170
171		/**
172		* Unlocking an unlocked lock throws IllegalMonitorStateException
173		*/
174		public void testUnlock_IllegalMonitorStateException() {
175	<	ReentrantLock rl = new ReentrantLock();
175	>	ReentrantLock lock = new ReentrantLock();
176		try {
177	<	rl.unlock();
177	>	lock.unlock();
178		shouldThrow();
179		} catch (IllegalMonitorStateException success) {}
180		}
#	Line 103 | Line 183 | public class ReentrantLockTest extends J
183		* tryLock on an unlocked lock succeeds
184		*/
185		public void testTryLock() {
186	<	ReentrantLock rl = new ReentrantLock();
187	<	assertTrue(rl.tryLock());
188	<	assertTrue(rl.isLocked());
189	<	rl.unlock();
186	>	PublicReentrantLock lock = new PublicReentrantLock();
187	>	assertTrue(lock.tryLock());
188	>	assertLockedBy(lock, Thread.currentThread());
189	>	releaseLock(lock);
190		}
191
112	–
192		/**
193		* hasQueuedThreads reports whether there are waiting threads
194		*/
195	<	public void testhasQueuedThreads() throws InterruptedException {
196	<	final ReentrantLock lock = new ReentrantLock();
195	>	public void testHasQueuedThreads() throws InterruptedException {
196	>	final PublicReentrantLock lock = new PublicReentrantLock();
197		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
198		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
199		assertFalse(lock.hasQueuedThreads());
200		lock.lock();
201	+	assertFalse(lock.hasQueuedThreads());
202		t1.start();
203	<	Thread.sleep(SHORT_DELAY_MS);
203	>	waitForQueuedThread(lock, t1);
204		assertTrue(lock.hasQueuedThreads());
205		t2.start();
206	<	Thread.sleep(SHORT_DELAY_MS);
206	>	waitForQueuedThread(lock, t2);
207		assertTrue(lock.hasQueuedThreads());
208		t1.interrupt();
209	<	Thread.sleep(SHORT_DELAY_MS);
209	>	awaitTermination(t1);
210		assertTrue(lock.hasQueuedThreads());
211		lock.unlock();
212	<	Thread.sleep(SHORT_DELAY_MS);
212	>	awaitTermination(t2);
213		assertFalse(lock.hasQueuedThreads());
134	–	t1.join();
135	–	t2.join();
214		}
215
216		/**
217		* getQueueLength reports number of waiting threads
218		*/
219		public void testGetQueueLength() throws InterruptedException {
220	<	final ReentrantLock lock = new ReentrantLock();
220	>	final PublicReentrantLock lock = new PublicReentrantLock();
221		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
222		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
223		assertEquals(0, lock.getQueueLength());
224		lock.lock();
225		t1.start();
226	<	Thread.sleep(SHORT_DELAY_MS);
226	>	waitForQueuedThread(lock, t1);
227		assertEquals(1, lock.getQueueLength());
228		t2.start();
229	<	Thread.sleep(SHORT_DELAY_MS);
229	>	waitForQueuedThread(lock, t2);
230		assertEquals(2, lock.getQueueLength());
231		t1.interrupt();
232	<	Thread.sleep(SHORT_DELAY_MS);
232	>	awaitTermination(t1);
233		assertEquals(1, lock.getQueueLength());
234		lock.unlock();
235	<	Thread.sleep(SHORT_DELAY_MS);
235	>	awaitTermination(t2);
236		assertEquals(0, lock.getQueueLength());
159	–	t1.join();
160	–	t2.join();
237		}
238
239		/**
240		* getQueueLength reports number of waiting threads
241		*/
242		public void testGetQueueLength_fair() throws InterruptedException {
243	<	final ReentrantLock lock = new ReentrantLock(true);
243	>	final PublicReentrantLock lock = new PublicReentrantLock(true);
244		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
245		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
246		assertEquals(0, lock.getQueueLength());
247		lock.lock();
248		t1.start();
249	<	Thread.sleep(SHORT_DELAY_MS);
249	>	waitForQueuedThread(lock, t1);
250		assertEquals(1, lock.getQueueLength());
251		t2.start();
252	<	Thread.sleep(SHORT_DELAY_MS);
252	>	waitForQueuedThread(lock, t2);
253		assertEquals(2, lock.getQueueLength());
254		t1.interrupt();
255	<	Thread.sleep(SHORT_DELAY_MS);
255	>	awaitTermination(t1);
256		assertEquals(1, lock.getQueueLength());
257		lock.unlock();
258	<	Thread.sleep(SHORT_DELAY_MS);
258	>	awaitTermination(t2);
259		assertEquals(0, lock.getQueueLength());
184	–	t1.join();
185	–	t2.join();
260		}
261
262		/**
263		* hasQueuedThread(null) throws NPE
264		*/
265		public void testHasQueuedThreadNPE() {
266	<	final ReentrantLock sync = new ReentrantLock();
266	>	final ReentrantLock lock = new ReentrantLock();
267		try {
268	<	sync.hasQueuedThread(null);
268	>	lock.hasQueuedThread(null);
269		shouldThrow();
270		} catch (NullPointerException success) {}
271		}
#	Line 200 | Line 274 | public class ReentrantLockTest extends J
274		* hasQueuedThread reports whether a thread is queued.
275		*/
276		public void testHasQueuedThread() throws InterruptedException {
277	<	final ReentrantLock sync = new ReentrantLock();
278	<	Thread t1 = new Thread(new InterruptedLockRunnable(sync));
279	<	Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
280	<	assertFalse(sync.hasQueuedThread(t1));
281	<	assertFalse(sync.hasQueuedThread(t2));
282	<	sync.lock();
277	>	final PublicReentrantLock lock = new PublicReentrantLock();
278	>	Thread t1 = new Thread(new InterruptedLockRunnable(lock));
279	>	Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
280	>	assertFalse(lock.hasQueuedThread(t1));
281	>	assertFalse(lock.hasQueuedThread(t2));
282	>	lock.lock();
283		t1.start();
284	<	Thread.sleep(SHORT_DELAY_MS);
285	<	assertTrue(sync.hasQueuedThread(t1));
284	>	waitForQueuedThread(lock, t1);
285	>	assertTrue(lock.hasQueuedThread(t1));
286	>	assertFalse(lock.hasQueuedThread(t2));
287		t2.start();
288	<	Thread.sleep(SHORT_DELAY_MS);
289	<	assertTrue(sync.hasQueuedThread(t1));
290	<	assertTrue(sync.hasQueuedThread(t2));
288	>	waitForQueuedThread(lock, t2);
289	>	assertTrue(lock.hasQueuedThread(t1));
290	>	assertTrue(lock.hasQueuedThread(t2));
291		t1.interrupt();
292	<	Thread.sleep(SHORT_DELAY_MS);
293	<	assertFalse(sync.hasQueuedThread(t1));
294	<	assertTrue(sync.hasQueuedThread(t2));
295	<	sync.unlock();
296	<	Thread.sleep(SHORT_DELAY_MS);
297	<	assertFalse(sync.hasQueuedThread(t1));
298	<	Thread.sleep(SHORT_DELAY_MS);
224	<	assertFalse(sync.hasQueuedThread(t2));
225	<	t1.join();
226	<	t2.join();
292	>	awaitTermination(t1);
293	>	assertFalse(lock.hasQueuedThread(t1));
294	>	assertTrue(lock.hasQueuedThread(t2));
295	>	lock.unlock();
296	>	awaitTermination(t2);
297	>	assertFalse(lock.hasQueuedThread(t1));
298	>	assertFalse(lock.hasQueuedThread(t2));
299		}
300
229	–
301		/**
302		* getQueuedThreads includes waiting threads
303		*/
#	Line 238 | Line 309 | public class ReentrantLockTest extends J
309		lock.lock();
310		assertTrue(lock.getQueuedThreads().isEmpty());
311		t1.start();
312	<	Thread.sleep(SHORT_DELAY_MS);
312	>	waitForQueuedThread(lock, t1);
313	>	assertEquals(1, lock.getQueuedThreads().size());
314		assertTrue(lock.getQueuedThreads().contains(t1));
315		t2.start();
316	<	Thread.sleep(SHORT_DELAY_MS);
316	>	waitForQueuedThread(lock, t2);
317	>	assertEquals(2, lock.getQueuedThreads().size());
318		assertTrue(lock.getQueuedThreads().contains(t1));
319		assertTrue(lock.getQueuedThreads().contains(t2));
320		t1.interrupt();
321	<	Thread.sleep(SHORT_DELAY_MS);
321	>	awaitTermination(t1);
322		assertFalse(lock.getQueuedThreads().contains(t1));
323		assertTrue(lock.getQueuedThreads().contains(t2));
324	+	assertEquals(1, lock.getQueuedThreads().size());
325		lock.unlock();
326	<	Thread.sleep(SHORT_DELAY_MS);
326	>	awaitTermination(t2);
327		assertTrue(lock.getQueuedThreads().isEmpty());
254	–	t1.join();
255	–	t2.join();
328		}
329
258	–
330		/**
331		* timed tryLock is interruptible.
332		*/
333	<	public void testInterruptedException2() throws InterruptedException {
334	<	final ReentrantLock lock = new ReentrantLock();
333	>	public void testTryLock_Interrupted() throws InterruptedException {
334	>	final PublicReentrantLock lock = new PublicReentrantLock();
335		lock.lock();
336	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
336	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
337		public void realRun() throws InterruptedException {
338	<	lock.tryLock(MEDIUM_DELAY_MS,MILLISECONDS);
338	>	lock.tryLock(2 * LONG_DELAY_MS, MILLISECONDS);
339		}});
340
341	<	t.start();
271	<	Thread.sleep(SHORT_DELAY_MS);
341	>	waitForQueuedThread(lock, t);
342		t.interrupt();
343	<	t.join();
343	>	awaitTermination(t);
344	>	releaseLock(lock);
345		}
346
276	–
347		/**
348	<	* TryLock on a locked lock fails
348	>	* tryLock on a locked lock fails
349		*/
350		public void testTryLockWhenLocked() throws InterruptedException {
351	<	final ReentrantLock lock = new ReentrantLock();
351	>	final PublicReentrantLock lock = new PublicReentrantLock();
352		lock.lock();
353	<	Thread t = new Thread(new CheckedRunnable() {
353	>	Thread t = newStartedThread(new CheckedRunnable() {
354		public void realRun() {
355		assertFalse(lock.tryLock());
356		}});
357
358	<	t.start();
359	<	t.join();
290	<	lock.unlock();
358	>	awaitTermination(t);
359	>	releaseLock(lock);
360		}
361
362		/**
363		* Timed tryLock on a locked lock times out
364		*/
365		public void testTryLock_Timeout() throws InterruptedException {
366	<	final ReentrantLock lock = new ReentrantLock();
366	>	final PublicReentrantLock lock = new PublicReentrantLock();
367		lock.lock();
368	<	Thread t = new Thread(new CheckedRunnable() {
368	>	Thread t = newStartedThread(new CheckedRunnable() {
369		public void realRun() throws InterruptedException {
370	<	assertFalse(lock.tryLock(1, MILLISECONDS));
370	>	long startTime = System.nanoTime();
371	>	long timeoutMillis = 10;
372	>	assertFalse(lock.tryLock(timeoutMillis, MILLISECONDS));
373	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
374		}});
375
376	<	t.start();
377	<	t.join();
306	<	lock.unlock();
376	>	awaitTermination(t);
377	>	releaseLock(lock);
378		}
379
380		/**
#	Line 321 | Line 392 | public class ReentrantLockTest extends J
392		}
393		}
394
324	–
395		/**
396		* isLocked is true when locked and false when not
397		*/
398	<	public void testIsLocked() throws InterruptedException {
398	>	public void testIsLocked() throws Exception {
399		final ReentrantLock lock = new ReentrantLock();
400	+	assertFalse(lock.isLocked());
401	+	lock.lock();
402	+	assertTrue(lock.isLocked());
403		lock.lock();
404		assertTrue(lock.isLocked());
405		lock.unlock();
406	+	assertTrue(lock.isLocked());
407	+	lock.unlock();
408		assertFalse(lock.isLocked());
409	<	Thread t = new Thread(new CheckedRunnable() {
410	<	public void realRun() throws InterruptedException {
409	>	final CyclicBarrier barrier = new CyclicBarrier(2);
410	>	Thread t = newStartedThread(new CheckedRunnable() {
411	>	public void realRun() throws Exception {
412		lock.lock();
413	<	Thread.sleep(SMALL_DELAY_MS);
413	>	assertTrue(lock.isLocked());
414	>	barrier.await();
415	>	barrier.await();
416		lock.unlock();
417		}});
418
419	<	t.start();
342	<	Thread.sleep(SHORT_DELAY_MS);
419	>	barrier.await();
420		assertTrue(lock.isLocked());
421	<	t.join();
421	>	barrier.await();
422	>	awaitTermination(t);
423		assertFalse(lock.isLocked());
424		}
425
348	–
426		/**
427		* lockInterruptibly is interruptible.
428		*/
429	<	public void testLockInterruptibly1() throws InterruptedException {
430	<	final ReentrantLock lock = new ReentrantLock();
429	>	public void testLockInterruptibly_Interrupted() throws InterruptedException {
430	>	final PublicReentrantLock lock = new PublicReentrantLock();
431		lock.lock();
432	<	Thread t = new Thread(new InterruptedLockRunnable(lock));
433	<	t.start();
357	<	Thread.sleep(SHORT_DELAY_MS);
432	>	Thread t = newStartedThread(new InterruptedLockRunnable(lock));
433	>	waitForQueuedThread(lock, t);
434		t.interrupt();
435	<	Thread.sleep(SHORT_DELAY_MS);
436	<	lock.unlock();
361	<	t.join();
435	>	awaitTermination(t);
436	>	releaseLock(lock);
437		}
438
439		/**
440		* lockInterruptibly succeeds when unlocked, else is interruptible
441		*/
442	<	public void testLockInterruptibly2() throws InterruptedException {
443	<	final ReentrantLock lock = new ReentrantLock();
442	>	public void testLockInterruptibly_Interrupted2() throws InterruptedException {
443	>	final PublicReentrantLock lock = new PublicReentrantLock();
444		lock.lockInterruptibly();
445	<	Thread t = new Thread(new InterruptedLockRunnable(lock));
446	<	t.start();
372	<	Thread.sleep(SHORT_DELAY_MS);
445	>	Thread t = newStartedThread(new InterruptedLockRunnable(lock));
446	>	waitForQueuedThread(lock, t);
447		t.interrupt();
448		assertTrue(lock.isLocked());
449		assertTrue(lock.isHeldByCurrentThread());
450	<	t.join();
450	>	awaitTermination(t);
451	>	releaseLock(lock);
452		}
453
454		/**
#	Line 386 | Line 461 | public class ReentrantLockTest extends J
461		c.await();
462		shouldThrow();
463		} catch (IllegalMonitorStateException success) {}
464	+	try {
465	+	c.await(LONG_DELAY_MS, MILLISECONDS);
466	+	shouldThrow();
467	+	} catch (IllegalMonitorStateException success) {}
468	+	try {
469	+	c.awaitNanos(100);
470	+	shouldThrow();
471	+	} catch (IllegalMonitorStateException success) {}
472	+	try {
473	+	c.awaitUninterruptibly();
474	+	shouldThrow();
475	+	} catch (IllegalMonitorStateException success) {}
476		}
477
478		/**
#	Line 407 | Line 494 | public class ReentrantLockTest extends J
494		final ReentrantLock lock = new ReentrantLock();
495		final Condition c = lock.newCondition();
496		lock.lock();
497	<	long t = c.awaitNanos(100);
498	<	assertTrue(t <= 0);
497	>	long startTime = System.nanoTime();
498	>	long timeoutMillis = 10;
499	>	long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
500	>	long nanosRemaining = c.awaitNanos(timeoutNanos);
501	>	assertTrue(nanosRemaining <= 0);
502	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
503		lock.unlock();
504		}
505
#	Line 419 | Line 510 | public class ReentrantLockTest extends J
510		final ReentrantLock lock = new ReentrantLock();
511		final Condition c = lock.newCondition();
512		lock.lock();
513	<	assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS));
513	>	long startTime = System.nanoTime();
514	>	long timeoutMillis = 10;
515	>	assertFalse(c.await(timeoutMillis, MILLISECONDS));
516	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
517		lock.unlock();
518		}
519
#	Line 430 | Line 524 | public class ReentrantLockTest extends J
524		final ReentrantLock lock = new ReentrantLock();
525		final Condition c = lock.newCondition();
526		lock.lock();
527	+	long startTime = System.nanoTime();
528	+	long timeoutMillis = 10;
529		java.util.Date d = new java.util.Date();
530	<	assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
530	>	assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + timeoutMillis)));
531	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
532		lock.unlock();
533		}
534
#	Line 439 | Line 536 | public class ReentrantLockTest extends J
536		* await returns when signalled
537		*/
538		public void testAwait() throws InterruptedException {
539	<	final ReentrantLock lock = new ReentrantLock();
539	>	final PublicReentrantLock lock = new PublicReentrantLock();
540		final Condition c = lock.newCondition();
541	<	Thread t = new Thread(new CheckedRunnable() {
541	>	final CountDownLatch locked = new CountDownLatch(1);
542	>	Thread t = newStartedThread(new CheckedRunnable() {
543		public void realRun() throws InterruptedException {
544		lock.lock();
545	+	locked.countDown();
546		c.await();
547		lock.unlock();
548		}});
549
550	<	t.start();
452	<	Thread.sleep(SHORT_DELAY_MS);
550	>	locked.await();
551		lock.lock();
552	+	assertHasWaiters(lock, c, t);
553		c.signal();
554	+	assertHasNoWaiters(lock, c);
555	+	assertTrue(t.isAlive());
556		lock.unlock();
557	<	t.join(SHORT_DELAY_MS);
457	<	assertFalse(t.isAlive());
557	>	awaitTermination(t);
558		}
559
560		/**
#	Line 479 | Line 579 | public class ReentrantLockTest extends J
579		} catch (NullPointerException success) {}
580		}
581
482	–
582		/**
583		* getWaitingThreads throws NPE if null
584		*/
#	Line 491 | Line 590 | public class ReentrantLockTest extends J
590		} catch (NullPointerException success) {}
591		}
592
494	–
593		/**
594	<	* hasWaiters throws IAE if not owned
594	>	* hasWaiters throws IllegalArgumentException if not owned
595		*/
596		public void testHasWaitersIAE() {
597		final ReentrantLock lock = new ReentrantLock();
#	Line 506 | Line 604 | public class ReentrantLockTest extends J
604		}
605
606		/**
607	<	* hasWaiters throws IMSE if not locked
607	>	* hasWaiters throws IllegalMonitorStateException if not locked
608		*/
609		public void testHasWaitersIMSE() {
610		final ReentrantLock lock = new ReentrantLock();
#	Line 517 | Line 615 | public class ReentrantLockTest extends J
615		} catch (IllegalMonitorStateException success) {}
616		}
617
520	–
618		/**
619	<	* getWaitQueueLength throws IAE if not owned
619	>	* getWaitQueueLength throws IllegalArgumentException if not owned
620		*/
621		public void testGetWaitQueueLengthIAE() {
622		final ReentrantLock lock = new ReentrantLock();
#	Line 532 | Line 629 | public class ReentrantLockTest extends J
629		}
630
631		/**
632	<	* getWaitQueueLength throws IMSE if not locked
632	>	* getWaitQueueLength throws IllegalMonitorStateException if not locked
633		*/
634		public void testGetWaitQueueLengthIMSE() {
635		final ReentrantLock lock = new ReentrantLock();
#	Line 543 | Line 640 | public class ReentrantLockTest extends J
640		} catch (IllegalMonitorStateException success) {}
641		}
642
546	–
643		/**
644	<	* getWaitingThreads throws IAE if not owned
644	>	* getWaitingThreads throws IllegalArgumentException if not owned
645		*/
646		public void testGetWaitingThreadsIAE() {
647		final PublicReentrantLock lock = new PublicReentrantLock();
#	Line 558 | Line 654 | public class ReentrantLockTest extends J
654		}
655
656		/**
657	<	* getWaitingThreads throws IMSE if not locked
657	>	* getWaitingThreads throws IllegalMonitorStateException if not locked
658		*/
659		public void testGetWaitingThreadsIMSE() {
660		final PublicReentrantLock lock = new PublicReentrantLock();
#	Line 569 | Line 665 | public class ReentrantLockTest extends J
665		} catch (IllegalMonitorStateException success) {}
666		}
667
572	–
668		/**
669		* hasWaiters returns true when a thread is waiting, else false
670		*/
671		public void testHasWaiters() throws InterruptedException {
672	<	final ReentrantLock lock = new ReentrantLock();
672	>	final PublicReentrantLock lock = new PublicReentrantLock();
673		final Condition c = lock.newCondition();
674	<	Thread t = new Thread(new CheckedRunnable() {
674	>	final CountDownLatch locked = new CountDownLatch(1);
675	>	Thread t = newStartedThread(new CheckedRunnable() {
676		public void realRun() throws InterruptedException {
677		lock.lock();
678	+	assertHasNoWaiters(lock, c);
679		assertFalse(lock.hasWaiters(c));
680	<	assertEquals(0, lock.getWaitQueueLength(c));
680	>	locked.countDown();
681		c.await();
682	+	assertHasNoWaiters(lock, c);
683	+	assertFalse(lock.hasWaiters(c));
684		lock.unlock();
685		}});
686
687	<	t.start();
589	<	Thread.sleep(SHORT_DELAY_MS);
687	>	locked.await();
688		lock.lock();
689	+	assertHasWaiters(lock, c, t);
690		assertTrue(lock.hasWaiters(c));
592	–	assertEquals(1, lock.getWaitQueueLength(c));
691		c.signal();
692	<	lock.unlock();
595	<	Thread.sleep(SHORT_DELAY_MS);
596	<	lock.lock();
692	>	assertHasNoWaiters(lock, c);
693		assertFalse(lock.hasWaiters(c));
598	–	assertEquals(0, lock.getWaitQueueLength(c));
694		lock.unlock();
695	<	t.join(SHORT_DELAY_MS);
696	<	assertFalse(t.isAlive());
695	>	awaitTermination(t);
696	>	assertHasNoWaiters(lock, c);
697		}
698
699		/**
700		* getWaitQueueLength returns number of waiting threads
701		*/
702		public void testGetWaitQueueLength() throws InterruptedException {
703	<	final ReentrantLock lock = new ReentrantLock();
703	>	final PublicReentrantLock lock = new PublicReentrantLock();
704		final Condition c = lock.newCondition();
705	+	final CountDownLatch locked1 = new CountDownLatch(1);
706	+	final CountDownLatch locked2 = new CountDownLatch(1);
707		Thread t1 = new Thread(new CheckedRunnable() {
708		public void realRun() throws InterruptedException {
709		lock.lock();
710		assertFalse(lock.hasWaiters(c));
711		assertEquals(0, lock.getWaitQueueLength(c));
712	+	locked1.countDown();
713		c.await();
714		lock.unlock();
715		}});
#	Line 621 | Line 719 | public class ReentrantLockTest extends J
719		lock.lock();
720		assertTrue(lock.hasWaiters(c));
721		assertEquals(1, lock.getWaitQueueLength(c));
722	+	locked2.countDown();
723		c.await();
724		lock.unlock();
725		}});
726
727	+	lock.lock();
728	+	assertEquals(0, lock.getWaitQueueLength(c));
729	+	lock.unlock();
730	+
731		t1.start();
732	<	Thread.sleep(SHORT_DELAY_MS);
732	>	locked1.await();
733	>
734	>	lock.lock();
735	>	assertHasWaiters(lock, c, t1);
736	>	assertEquals(1, lock.getWaitQueueLength(c));
737	>	lock.unlock();
738	>
739		t2.start();
740	<	Thread.sleep(SHORT_DELAY_MS);
740	>	locked2.await();
741	>
742		lock.lock();
743	<	assertTrue(lock.hasWaiters(c));
743	>	assertHasWaiters(lock, c, t1, t2);
744		assertEquals(2, lock.getWaitQueueLength(c));
745		c.signalAll();
746	+	assertHasNoWaiters(lock, c);
747		lock.unlock();
748	<	Thread.sleep(SHORT_DELAY_MS);
749	<	lock.lock();
750	<	assertFalse(lock.hasWaiters(c));
751	<	assertEquals(0, lock.getWaitQueueLength(c));
752	<	lock.unlock();
642	<	t1.join(SHORT_DELAY_MS);
643	<	t2.join(SHORT_DELAY_MS);
644	<	assertFalse(t1.isAlive());
645	<	assertFalse(t2.isAlive());
748	>
749	>	awaitTermination(t1);
750	>	awaitTermination(t2);
751	>
752	>	assertHasNoWaiters(lock, c);
753		}
754
755		/**
#	Line 651 | Line 758 | public class ReentrantLockTest extends J
758		public void testGetWaitingThreads() throws InterruptedException {
759		final PublicReentrantLock lock = new PublicReentrantLock();
760		final Condition c = lock.newCondition();
761	+	final CountDownLatch locked1 = new CountDownLatch(1);
762	+	final CountDownLatch locked2 = new CountDownLatch(1);
763		Thread t1 = new Thread(new CheckedRunnable() {
764		public void realRun() throws InterruptedException {
765		lock.lock();
766		assertTrue(lock.getWaitingThreads(c).isEmpty());
767	+	locked1.countDown();
768		c.await();
769		lock.unlock();
770		}});
#	Line 663 | Line 773 | public class ReentrantLockTest extends J
773		public void realRun() throws InterruptedException {
774		lock.lock();
775		assertFalse(lock.getWaitingThreads(c).isEmpty());
776	+	locked2.countDown();
777		c.await();
778		lock.unlock();
779		}});
#	Line 670 | Line 781 | public class ReentrantLockTest extends J
781		lock.lock();
782		assertTrue(lock.getWaitingThreads(c).isEmpty());
783		lock.unlock();
784	+
785		t1.start();
786	<	Thread.sleep(SHORT_DELAY_MS);
786	>	locked1.await();
787	>
788	>	lock.lock();
789	>	assertHasWaiters(lock, c, t1);
790	>	assertTrue(lock.getWaitingThreads(c).contains(t1));
791	>	assertFalse(lock.getWaitingThreads(c).contains(t2));
792	>	assertEquals(1, lock.getWaitingThreads(c).size());
793	>	lock.unlock();
794	>
795		t2.start();
796	<	Thread.sleep(SHORT_DELAY_MS);
796	>	locked2.await();
797	>
798		lock.lock();
799	<	assertTrue(lock.hasWaiters(c));
799	>	assertHasWaiters(lock, c, t1, t2);
800		assertTrue(lock.getWaitingThreads(c).contains(t1));
801		assertTrue(lock.getWaitingThreads(c).contains(t2));
802	+	assertEquals(2, lock.getWaitingThreads(c).size());
803		c.signalAll();
804	+	assertHasNoWaiters(lock, c);
805		lock.unlock();
683	–	Thread.sleep(SHORT_DELAY_MS);
684	–	lock.lock();
685	–	assertFalse(lock.hasWaiters(c));
686	–	assertTrue(lock.getWaitingThreads(c).isEmpty());
687	–	lock.unlock();
688	–	t1.join(SHORT_DELAY_MS);
689	–	t2.join(SHORT_DELAY_MS);
690	–	assertFalse(t1.isAlive());
691	–	assertFalse(t2.isAlive());
692	–	}
693	–
694	–	/** A helper class for uninterruptible wait tests */
695	–	class UninterruptibleThread extends Thread {
696	–	private ReentrantLock lock;
697	–	private Condition c;
698	–
699	–	public volatile boolean canAwake = false;
700	–	public volatile boolean interrupted = false;
701	–	public volatile boolean lockStarted = false;
702	–
703	–	public UninterruptibleThread(ReentrantLock lock, Condition c) {
704	–	this.lock = lock;
705	–	this.c = c;
706	–	}
806
807	<	public synchronized void run() {
808	<	lock.lock();
710	<	lockStarted = true;
711	<
712	<	while (!canAwake) {
713	<	c.awaitUninterruptibly();
714	<	}
807	>	awaitTermination(t1);
808	>	awaitTermination(t2);
809
810	<	interrupted = isInterrupted();
717	<	lock.unlock();
718	<	}
810	>	assertHasNoWaiters(lock, c);
811		}
812
813		/**
#	Line 724 | Line 816 | public class ReentrantLockTest extends J
816		public void testAwaitUninterruptibly() throws InterruptedException {
817		final ReentrantLock lock = new ReentrantLock();
818		final Condition c = lock.newCondition();
819	<	UninterruptibleThread thread = new UninterruptibleThread(lock, c);
820	<
821	<	thread.start();
822	<
823	<	while (!thread.lockStarted) {
824	<	Thread.sleep(100);
825	<	}
819	>	final CountDownLatch locked = new CountDownLatch(1);
820	>	Thread t = newStartedThread(new CheckedRunnable() {
821	>	public void realRun() {
822	>	lock.lock();
823	>	locked.countDown();
824	>	c.awaitUninterruptibly();
825	>	assertTrue(Thread.interrupted());
826	>	lock.unlock();
827	>	}});
828
829	+	locked.await();
830		lock.lock();
831	<	try {
832	<	thread.interrupt();
833	<	thread.canAwake = true;
834	<	c.signal();
835	<	} finally {
836	<	lock.unlock();
837	<	}
838	<
744	<	thread.join();
745	<	assertTrue(thread.interrupted);
746	<	assertFalse(thread.isAlive());
831	>	lock.unlock();
832	>	t.interrupt();
833	>	long timeoutMillis = 10;
834	>	assertThreadJoinTimesOut(t, timeoutMillis);
835	>	lock.lock();
836	>	c.signal();
837	>	lock.unlock();
838	>	awaitTermination(t);
839		}
840
841		/**
842		* await is interruptible
843		*/
844		public void testAwait_Interrupt() throws InterruptedException {
845	<	final ReentrantLock lock = new ReentrantLock();
845	>	final PublicReentrantLock lock = new PublicReentrantLock();
846		final Condition c = lock.newCondition();
847	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
847	>	final CountDownLatch locked = new CountDownLatch(1);
848	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
849		public void realRun() throws InterruptedException {
850		lock.lock();
851	<	c.await();
851	>	assertTrue(lock.isLocked());
852	>	assertTrue(lock.isHeldByCurrentThread());
853	>	assertHasNoWaiters(lock, c);
854	>	locked.countDown();
855	>	try {
856	>	c.await();
857	>	} finally {
858	>	assertTrue(lock.isLocked());
859	>	assertTrue(lock.isHeldByCurrentThread());
860	>	assertHasNoWaiters(lock, c);
861	>	lock.unlock();
862	>	assertFalse(Thread.interrupted());
863	>	}
864		}});
865
866	<	t.start();
867	<	Thread.sleep(SHORT_DELAY_MS);
866	>	locked.await();
867	>	assertHasWaiters(lock, c, t);
868		t.interrupt();
869	<	t.join(SHORT_DELAY_MS);
870	<	assertFalse(t.isAlive());
869	>	awaitTermination(t);
870	>	assertFalse(lock.isLocked());
871		}
872
873		/**
874		* awaitNanos is interruptible
875		*/
876		public void testAwaitNanos_Interrupt() throws InterruptedException {
877	<	final ReentrantLock lock = new ReentrantLock();
877	>	final PublicReentrantLock lock = new PublicReentrantLock();
878		final Condition c = lock.newCondition();
879	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
879	>	final CountDownLatch locked = new CountDownLatch(1);
880	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
881		public void realRun() throws InterruptedException {
882		lock.lock();
883	<	c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
883	>	assertTrue(lock.isLocked());
884	>	assertTrue(lock.isHeldByCurrentThread());
885	>	assertHasNoWaiters(lock, c);
886	>	locked.countDown();
887	>	try {
888	>	c.awaitNanos(MILLISECONDS.toNanos(2 * LONG_DELAY_MS));
889	>	} finally {
890	>	assertTrue(lock.isLocked());
891	>	assertTrue(lock.isHeldByCurrentThread());
892	>	assertHasNoWaiters(lock, c);
893	>	lock.unlock();
894	>	assertFalse(Thread.interrupted());
895	>	}
896		}});
897
898	<	t.start();
899	<	Thread.sleep(SHORT_DELAY_MS);
898	>	locked.await();
899	>	assertHasWaiters(lock, c, t);
900		t.interrupt();
901	<	t.join(SHORT_DELAY_MS);
902	<	assertFalse(t.isAlive());
901	>	awaitTermination(t);
902	>	assertFalse(lock.isLocked());
903		}
904
905		/**
906		* awaitUntil is interruptible
907		*/
908		public void testAwaitUntil_Interrupt() throws InterruptedException {
909	<	final ReentrantLock lock = new ReentrantLock();
909	>	final PublicReentrantLock lock = new PublicReentrantLock();
910		final Condition c = lock.newCondition();
911	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
911	>	final CountDownLatch locked = new CountDownLatch(1);
912	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
913		public void realRun() throws InterruptedException {
914		lock.lock();
915	+	assertTrue(lock.isLocked());
916	+	assertTrue(lock.isHeldByCurrentThread());
917	+	assertHasNoWaiters(lock, c);
918	+	locked.countDown();
919		java.util.Date d = new java.util.Date();
920	<	c.awaitUntil(new java.util.Date(d.getTime() + 10000));
920	>	try {
921	>	c.awaitUntil(new java.util.Date(d.getTime() + 2 * LONG_DELAY_MS));
922	>	} finally {
923	>	assertTrue(lock.isLocked());
924	>	assertTrue(lock.isHeldByCurrentThread());
925	>	assertHasNoWaiters(lock, c);
926	>	lock.unlock();
927	>	assertFalse(Thread.interrupted());
928	>	}
929		}});
930
931	<	t.start();
932	<	Thread.sleep(SHORT_DELAY_MS);
931	>	locked.await();
932	>	assertHasWaiters(lock, c, t);
933		t.interrupt();
934	<	t.join(SHORT_DELAY_MS);
935	<	assertFalse(t.isAlive());
934	>	awaitTermination(t);
935	>	assertFalse(lock.isLocked());
936		}
937
938		/**
939		* signalAll wakes up all threads
940		*/
941		public void testSignalAll() throws InterruptedException {
942	<	final ReentrantLock lock = new ReentrantLock();
942	>	final PublicReentrantLock lock = new PublicReentrantLock();
943		final Condition c = lock.newCondition();
944	<	Thread t1 = new Thread(new CheckedRunnable() {
944	>	final CountDownLatch locked = new CountDownLatch(2);
945	>	Thread t1 = newStartedThread(new CheckedRunnable() {
946		public void realRun() throws InterruptedException {
947		lock.lock();
948	+	locked.countDown();
949		c.await();
950		lock.unlock();
951		}});
952
953	<	Thread t2 = new Thread(new CheckedRunnable() {
953	>	Thread t2 = newStartedThread(new CheckedRunnable() {
954		public void realRun() throws InterruptedException {
955		lock.lock();
956	+	locked.countDown();
957		c.await();
958		lock.unlock();
959		}});
960
961	<	t1.start();
828	<	t2.start();
829	<	Thread.sleep(SHORT_DELAY_MS);
961	>	locked.await();
962		lock.lock();
963	+	assertHasWaiters(lock, c, t1, t2);
964		c.signalAll();
965	+	assertHasNoWaiters(lock, c);
966		lock.unlock();
967	<	t1.join(SHORT_DELAY_MS);
968	<	t2.join(SHORT_DELAY_MS);
835	<	assertFalse(t1.isAlive());
836	<	assertFalse(t2.isAlive());
967	>	awaitTermination(t1);
968	>	awaitTermination(t2);
969		}
970
971		/**
972		* await after multiple reentrant locking preserves lock count
973		*/
974		public void testAwaitLockCount() throws InterruptedException {
975	<	final ReentrantLock lock = new ReentrantLock();
975	>	final PublicReentrantLock lock = new PublicReentrantLock();
976		final Condition c = lock.newCondition();
977	<	Thread t1 = new Thread(new CheckedRunnable() {
977	>	final CountDownLatch locked = new CountDownLatch(2);
978	>	Thread t1 = newStartedThread(new CheckedRunnable() {
979		public void realRun() throws InterruptedException {
980		lock.lock();
981	+	assertLockedBy(lock, Thread.currentThread());
982		assertEquals(1, lock.getHoldCount());
983	+	locked.countDown();
984		c.await();
985	+	assertLockedBy(lock, Thread.currentThread());
986		assertEquals(1, lock.getHoldCount());
987		lock.unlock();
988		}});
989
990	<	Thread t2 = new Thread(new CheckedRunnable() {
990	>	Thread t2 = newStartedThread(new CheckedRunnable() {
991		public void realRun() throws InterruptedException {
992		lock.lock();
993		lock.lock();
994	+	assertLockedBy(lock, Thread.currentThread());
995		assertEquals(2, lock.getHoldCount());
996	+	locked.countDown();
997		c.await();
998	+	assertLockedBy(lock, Thread.currentThread());
999		assertEquals(2, lock.getHoldCount());
1000		lock.unlock();
1001		lock.unlock();
1002		}});
1003
1004	<	t1.start();
866	<	t2.start();
867	<	Thread.sleep(SHORT_DELAY_MS);
1004	>	locked.await();
1005		lock.lock();
1006	+	assertHasWaiters(lock, c, t1, t2);
1007	+	assertEquals(1, lock.getHoldCount());
1008		c.signalAll();
1009	+	assertHasNoWaiters(lock, c);
1010		lock.unlock();
1011	<	t1.join(SHORT_DELAY_MS);
1012	<	t2.join(SHORT_DELAY_MS);
873	<	assertFalse(t1.isAlive());
874	<	assertFalse(t2.isAlive());
1011	>	awaitTermination(t1);
1012	>	awaitTermination(t2);
1013		}
1014
1015		/**
#	Line 908 | Line 1046 | public class ReentrantLockTest extends J
1046		String ls = lock.toString();
1047		assertTrue(ls.indexOf("Locked") >= 0);
1048		}
911	–
1049		}

Diff Legend

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