ViewVC Help

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

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

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents):
Revision 1.33 by jsr166, Tue Nov 17 14:33:55 2009 UTC vs.
Revision 1.53 by jsr166, Mon May 2 00:49: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 9 | Line 9
9		import junit.framework.*;
10		import java.util.concurrent.locks.*;
11		import java.util.concurrent.*;
12	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
13		import java.io.*;
14		import java.util.*;
15
16		public class ReentrantReadWriteLockTest extends JSR166TestCase {
17		public static void main(String[] args) {
18	<	junit.textui.TestRunner.run (suite());
18	>	junit.textui.TestRunner.run(suite());
19		}
20		public static Test suite() {
21	<	return new TestSuite(ReentrantReadWriteLockTest.class);
21	>	return new TestSuite(ReentrantReadWriteLockTest.class);
22		}
23
24		/**
#	Line 58 | Line 59 | public class ReentrantReadWriteLockTest
59		}
60
61		/**
62	+	* Releases lock, checking that it had a hold count of 1.
63	+	*/
64	+	void releaseLock(ReentrantReadWriteLock.WriteLock lock) {
65	+	assertTrue(lock.isHeldByCurrentThread());
66	+	lock.unlock();
67	+	assertFalse(lock.isHeldByCurrentThread());
68	+	}
69	+
70	+	/**
71		* Constructor sets given fairness, and is in unlocked state
72		*/
73		public void testConstructor() {
74	<	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
74	>	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
75		assertFalse(rl.isFair());
76		assertFalse(rl.isWriteLocked());
77		assertEquals(0, rl.getReadLockCount());
78	<	ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
78	>	ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
79		assertTrue(r2.isFair());
80		assertFalse(r2.isWriteLocked());
81		assertEquals(0, r2.getReadLockCount());
82	<	ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false);
82	>	ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false);
83		assertFalse(r3.isFair());
84		assertFalse(r3.isWriteLocked());
85		assertEquals(0, r3.getReadLockCount());
#	Line 79 | Line 89 | public class ReentrantReadWriteLockTest
89		* write-locking and read-locking an unlocked lock succeed
90		*/
91		public void testLock() {
92	<	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
92	>	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
93		rl.writeLock().lock();
94		assertTrue(rl.isWriteLocked());
95		assertTrue(rl.isWriteLockedByCurrentThread());
#	Line 105 | Line 115 | public class ReentrantReadWriteLockTest
115		* locking an unlocked fair lock succeeds
116		*/
117		public void testFairLock() {
118	<	ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
118	>	ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
119		rl.writeLock().lock();
120		assertTrue(rl.isWriteLocked());
121		assertTrue(rl.isWriteLockedByCurrentThread());
#	Line 130 | Line 140 | public class ReentrantReadWriteLockTest
140		* getWriteHoldCount returns number of recursive holds
141		*/
142		public void testGetWriteHoldCount() {
143	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
144	<	for (int i = 1; i <= SIZE; i++) {
145	<	lock.writeLock().lock();
146	<	assertEquals(i,lock.getWriteHoldCount());
147	<	}
148	<	for (int i = SIZE; i > 0; i--) {
149	<	lock.writeLock().unlock();
150	<	assertEquals(i-1,lock.getWriteHoldCount());
151	<	}
143	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
144	>	for (int i = 1; i <= SIZE; i++) {
145	>	lock.writeLock().lock();
146	>	assertEquals(i,lock.getWriteHoldCount());
147	>	}
148	>	for (int i = SIZE; i > 0; i--) {
149	>	lock.writeLock().unlock();
150	>	assertEquals(i-1,lock.getWriteHoldCount());
151	>	}
152		}
153
154		/**
155		* WriteLock.getHoldCount returns number of recursive holds
156		*/
157		public void testGetHoldCount() {
158	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
159	<	for (int i = 1; i <= SIZE; i++) {
160	<	lock.writeLock().lock();
161	<	assertEquals(i,lock.writeLock().getHoldCount());
162	<	}
163	<	for (int i = SIZE; i > 0; i--) {
164	<	lock.writeLock().unlock();
165	<	assertEquals(i-1,lock.writeLock().getHoldCount());
166	<	}
158	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
159	>	for (int i = 1; i <= SIZE; i++) {
160	>	lock.writeLock().lock();
161	>	assertEquals(i,lock.writeLock().getHoldCount());
162	>	}
163	>	for (int i = SIZE; i > 0; i--) {
164	>	lock.writeLock().unlock();
165	>	assertEquals(i-1,lock.writeLock().getHoldCount());
166	>	}
167		}
168
169		/**
170		* getReadHoldCount returns number of recursive holds
171		*/
172		public void testGetReadHoldCount() {
173	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
174	<	for (int i = 1; i <= SIZE; i++) {
175	<	lock.readLock().lock();
176	<	assertEquals(i,lock.getReadHoldCount());
177	<	}
178	<	for (int i = SIZE; i > 0; i--) {
179	<	lock.readLock().unlock();
180	<	assertEquals(i-1,lock.getReadHoldCount());
181	<	}
173	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
174	>	for (int i = 1; i <= SIZE; i++) {
175	>	lock.readLock().lock();
176	>	assertEquals(i,lock.getReadHoldCount());
177	>	}
178	>	for (int i = SIZE; i > 0; i--) {
179	>	lock.readLock().unlock();
180	>	assertEquals(i-1,lock.getReadHoldCount());
181	>	}
182		}
183
184
#	Line 176 | Line 186 | public class ReentrantReadWriteLockTest
186		* write-unlocking an unlocked lock throws IllegalMonitorStateException
187		*/
188		public void testUnlock_IllegalMonitorStateException() {
189	<	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
190	<	try {
191	<	rl.writeLock().unlock();
192	<	shouldThrow();
193	<	} catch (IllegalMonitorStateException success) {}
189	>	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
190	>	try {
191	>	rl.writeLock().unlock();
192	>	shouldThrow();
193	>	} catch (IllegalMonitorStateException success) {}
194		}
195
196
#	Line 188 | Line 198 | public class ReentrantReadWriteLockTest
198		* write-lockInterruptibly is interruptible
199		*/
200		public void testWriteLockInterruptibly_Interrupted() throws Exception {
201	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
202	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
201	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
202	>	lock.writeLock().lock();
203	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
204		public void realRun() throws InterruptedException {
205		lock.writeLock().lockInterruptibly();
195	–	lock.writeLock().unlock();
196	–	lock.writeLock().lockInterruptibly();
197	–	lock.writeLock().unlock();
206		}});
207
200	–	lock.writeLock().lock();
201	–	t.start();
208		Thread.sleep(SHORT_DELAY_MS);
209		t.interrupt();
210	<	Thread.sleep(SHORT_DELAY_MS);
211	<	lock.writeLock().unlock();
206	<	t.join();
210	>	awaitTermination(t, LONG_DELAY_MS);
211	>	releaseLock(lock.writeLock());
212		}
213
214		/**
215		* timed write-tryLock is interruptible
216		*/
217		public void testWriteTryLock_Interrupted() throws InterruptedException {
218	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
219	<	lock.writeLock().lock();
220	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
218	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
219	>	lock.writeLock().lock();
220	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
221		public void realRun() throws InterruptedException {
222	<	lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS);
222	>	lock.writeLock().tryLock(SMALL_DELAY_MS, MILLISECONDS);
223		}});
224
225	<	t.start();
225	>	Thread.sleep(SHORT_DELAY_MS);
226		t.interrupt();
227	<	lock.writeLock().unlock();
228	<	t.join();
227	>	awaitTermination(t, LONG_DELAY_MS);
228	>	releaseLock(lock.writeLock());
229		}
230
231		/**
232		* read-lockInterruptibly is interruptible
233		*/
234		public void testReadLockInterruptibly_Interrupted() throws InterruptedException {
235	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
236	<	lock.writeLock().lock();
237	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
235	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
236	>	lock.writeLock().lock();
237	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
238		public void realRun() throws InterruptedException {
239		lock.readLock().lockInterruptibly();
240		}});
241
237	–	t.start();
242		Thread.sleep(SHORT_DELAY_MS);
243		t.interrupt();
244	<	Thread.sleep(SHORT_DELAY_MS);
245	<	lock.writeLock().unlock();
242	<	t.join();
244	>	awaitTermination(t, LONG_DELAY_MS);
245	>	releaseLock(lock.writeLock());
246		}
247
248		/**
249		* timed read-tryLock is interruptible
250		*/
251		public void testReadTryLock_Interrupted() throws InterruptedException {
252	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
253	<	lock.writeLock().lock();
254	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
252	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
253	>	lock.writeLock().lock();
254	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
255		public void realRun() throws InterruptedException {
256	<	lock.readLock().tryLock(1000,TimeUnit.MILLISECONDS);
256	>	lock.readLock().tryLock(LONG_DELAY_MS, MILLISECONDS);
257		}});
258
259	<	t.start();
259	>	Thread.sleep(SHORT_DELAY_MS);
260		t.interrupt();
261	<	t.join();
261	>	awaitTermination(t, LONG_DELAY_MS);
262	>	releaseLock(lock.writeLock());
263		}
264
265
#	Line 263 | Line 267 | public class ReentrantReadWriteLockTest
267		* write-tryLock fails if locked
268		*/
269		public void testWriteTryLockWhenLocked() throws InterruptedException {
270	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
271	<	lock.writeLock().lock();
272	<	Thread t = new Thread(new Runnable() {
273	<	public void run() {
274	<	threadAssertFalse(lock.writeLock().tryLock());
275	<	}
272	<	});
270	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
271	>	lock.writeLock().lock();
272	>	Thread t = newStartedThread(new CheckedRunnable() {
273	>	public void realRun() {
274	>	assertFalse(lock.writeLock().tryLock());
275	>	}});
276
277	<	t.start();
275	<	t.join();
277	>	awaitTermination(t, LONG_DELAY_MS);
278		lock.writeLock().unlock();
279		}
280
#	Line 280 | Line 282 | public class ReentrantReadWriteLockTest
282		* read-tryLock fails if locked
283		*/
284		public void testReadTryLockWhenLocked() throws InterruptedException {
285	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
286	<	lock.writeLock().lock();
287	<	Thread t = new Thread(new Runnable() {
288	<	public void run() {
289	<	threadAssertFalse(lock.readLock().tryLock());
290	<	}
289	<	});
285	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
286	>	lock.writeLock().lock();
287	>	Thread t = newStartedThread(new CheckedRunnable() {
288	>	public void realRun() {
289	>	assertFalse(lock.readLock().tryLock());
290	>	}});
291
292	<	t.start();
292	<	t.join();
292	>	awaitTermination(t, LONG_DELAY_MS);
293		lock.writeLock().unlock();
294		}
295
#	Line 297 | Line 297 | public class ReentrantReadWriteLockTest
297		* Multiple threads can hold a read lock when not write-locked
298		*/
299		public void testMultipleReadLocks() throws InterruptedException {
300	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
301	<	lock.readLock().lock();
302	<	Thread t = new Thread(new Runnable() {
303	<	public void run() {
304	<	threadAssertTrue(lock.readLock().tryLock());
305	<	lock.readLock().unlock();
306	<	}
307	<	});
300	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
301	>	lock.readLock().lock();
302	>	Thread t = newStartedThread(new CheckedRunnable() {
303	>	public void realRun() {
304	>	assertTrue(lock.readLock().tryLock());
305	>	lock.readLock().unlock();
306	>	}});
307
308	<	t.start();
310	<	t.join();
308	>	awaitTermination(t, LONG_DELAY_MS);
309		lock.readLock().unlock();
310		}
311
#	Line 315 | Line 313 | public class ReentrantReadWriteLockTest
313		* A writelock succeeds after reading threads unlock
314		*/
315		public void testWriteAfterMultipleReadLocks() throws InterruptedException {
316	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
317	<	lock.readLock().lock();
318	<	Thread t1 = new Thread(new Runnable() {
319	<	public void run() {
320	<	lock.readLock().lock();
321	<	lock.readLock().unlock();
322	<	}
323	<	});
324	<	Thread t2 = new Thread(new Runnable() {
325	<	public void run() {
326	<	lock.writeLock().lock();
327	<	lock.writeLock().unlock();
330	<	}
331	<	});
316	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
317	>	lock.readLock().lock();
318	>	Thread t1 = newStartedThread(new CheckedRunnable() {
319	>	public void realRun() {
320	>	lock.readLock().lock();
321	>	lock.readLock().unlock();
322	>	}});
323	>	Thread t2 = newStartedThread(new CheckedRunnable() {
324	>	public void realRun() {
325	>	lock.writeLock().lock();
326	>	lock.writeLock().unlock();
327	>	}});
328
333	–	t1.start();
334	–	t2.start();
329		Thread.sleep(SHORT_DELAY_MS);
330		lock.readLock().unlock();
331	<	t1.join(MEDIUM_DELAY_MS);
332	<	t2.join(MEDIUM_DELAY_MS);
339	<	assertTrue(!t1.isAlive());
340	<	assertTrue(!t2.isAlive());
331	>	awaitTermination(t1, LONG_DELAY_MS);
332	>	awaitTermination(t2, LONG_DELAY_MS);
333		}
334
335		/**
336		* Readlocks succeed after a writing thread unlocks
337		*/
338		public void testReadAfterWriteLock() throws InterruptedException {
339	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
340	<	lock.writeLock().lock();
341	<	Thread t1 = new Thread(new Runnable() {
342	<	public void run() {
343	<	lock.readLock().lock();
344	<	lock.readLock().unlock();
345	<	}
346	<	});
347	<	Thread t2 = new Thread(new Runnable() {
348	<	public void run() {
349	<	lock.readLock().lock();
350	<	lock.readLock().unlock();
359	<	}
360	<	});
339	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
340	>	lock.writeLock().lock();
341	>	Thread t1 = newStartedThread(new CheckedRunnable() {
342	>	public void realRun() {
343	>	lock.readLock().lock();
344	>	lock.readLock().unlock();
345	>	}});
346	>	Thread t2 = newStartedThread(new CheckedRunnable() {
347	>	public void realRun() {
348	>	lock.readLock().lock();
349	>	lock.readLock().unlock();
350	>	}});
351
362	–	t1.start();
363	–	t2.start();
352		Thread.sleep(SHORT_DELAY_MS);
353		lock.writeLock().unlock();
354	<	t1.join(MEDIUM_DELAY_MS);
355	<	t2.join(MEDIUM_DELAY_MS);
368	<	assertTrue(!t1.isAlive());
369	<	assertTrue(!t2.isAlive());
354	>	awaitTermination(t1, LONG_DELAY_MS);
355	>	awaitTermination(t2, LONG_DELAY_MS);
356		}
357
358		/**
359		* Read trylock succeeds if write locked by current thread
360		*/
361		public void testReadHoldingWriteLock() {
362	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
363	<	lock.writeLock().lock();
362	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
363	>	lock.writeLock().lock();
364		assertTrue(lock.readLock().tryLock());
365		lock.readLock().unlock();
366		lock.writeLock().unlock();
#	Line 385 | Line 371 | public class ReentrantReadWriteLockTest
371		* other threads are waiting for readlock
372		*/
373		public void testReadHoldingWriteLock2() throws InterruptedException {
374	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
375	<	lock.writeLock().lock();
376	<	Thread t1 = new Thread(new Runnable() {
377	<	public void run() {
378	<	lock.readLock().lock();
379	<	lock.readLock().unlock();
380	<	}
381	<	});
382	<	Thread t2 = new Thread(new Runnable() {
383	<	public void run() {
384	<	lock.readLock().lock();
385	<	lock.readLock().unlock();
400	<	}
401	<	});
374	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
375	>	lock.writeLock().lock();
376	>	Thread t1 = newStartedThread(new CheckedRunnable() {
377	>	public void realRun() {
378	>	lock.readLock().lock();
379	>	lock.readLock().unlock();
380	>	}});
381	>	Thread t2 = newStartedThread(new CheckedRunnable() {
382	>	public void realRun() {
383	>	lock.readLock().lock();
384	>	lock.readLock().unlock();
385	>	}});
386
403	–	t1.start();
404	–	t2.start();
387		lock.readLock().lock();
388		lock.readLock().unlock();
389		Thread.sleep(SHORT_DELAY_MS);
390		lock.readLock().lock();
391		lock.readLock().unlock();
392		lock.writeLock().unlock();
393	<	t1.join(MEDIUM_DELAY_MS);
394	<	t2.join(MEDIUM_DELAY_MS);
413	<	assertTrue(!t1.isAlive());
414	<	assertTrue(!t2.isAlive());
393	>	awaitTermination(t1, LONG_DELAY_MS);
394	>	awaitTermination(t2, LONG_DELAY_MS);
395		}
396
397		/**
398	<	*  Read lock succeeds if write locked by current thread even if
398	>	* Read lock succeeds if write locked by current thread even if
399		* other threads are waiting for writelock
400		*/
401		public void testReadHoldingWriteLock3() throws InterruptedException {
402	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
403	<	lock.writeLock().lock();
404	<	Thread t1 = new Thread(new Runnable() {
405	<	public void run() {
406	<	lock.writeLock().lock();
407	<	lock.writeLock().unlock();
408	<	}
409	<	});
410	<	Thread t2 = new Thread(new Runnable() {
411	<	public void run() {
412	<	lock.writeLock().lock();
413	<	lock.writeLock().unlock();
434	<	}
435	<	});
402	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
403	>	lock.writeLock().lock();
404	>	Thread t1 = newStartedThread(new CheckedRunnable() {
405	>	public void realRun() {
406	>	lock.writeLock().lock();
407	>	lock.writeLock().unlock();
408	>	}});
409	>	Thread t2 = newStartedThread(new CheckedRunnable() {
410	>	public void realRun() {
411	>	lock.writeLock().lock();
412	>	lock.writeLock().unlock();
413	>	}});
414
437	–	t1.start();
438	–	t2.start();
415		lock.readLock().lock();
416		lock.readLock().unlock();
417		Thread.sleep(SHORT_DELAY_MS);
418		lock.readLock().lock();
419		lock.readLock().unlock();
420		lock.writeLock().unlock();
421	<	t1.join(MEDIUM_DELAY_MS);
422	<	t2.join(MEDIUM_DELAY_MS);
447	<	assertTrue(!t1.isAlive());
448	<	assertTrue(!t2.isAlive());
421	>	awaitTermination(t1, LONG_DELAY_MS);
422	>	awaitTermination(t2, LONG_DELAY_MS);
423		}
424
425
426		/**
427	<	*  Write lock succeeds if write locked by current thread even if
427	>	* Write lock succeeds if write locked by current thread even if
428		* other threads are waiting for writelock
429		*/
430		public void testWriteHoldingWriteLock4() throws InterruptedException {
431	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
432	<	lock.writeLock().lock();
433	<	Thread t1 = new Thread(new Runnable() {
434	<	public void run() {
435	<	lock.writeLock().lock();
436	<	lock.writeLock().unlock();
437	<	}
438	<	});
439	<	Thread t2 = new Thread(new Runnable() {
440	<	public void run() {
441	<	lock.writeLock().lock();
442	<	lock.writeLock().unlock();
469	<	}
470	<	});
431	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
432	>	lock.writeLock().lock();
433	>	Thread t1 = newStartedThread(new CheckedRunnable() {
434	>	public void realRun() {
435	>	lock.writeLock().lock();
436	>	lock.writeLock().unlock();
437	>	}});
438	>	Thread t2 = newStartedThread(new CheckedRunnable() {
439	>	public void realRun() {
440	>	lock.writeLock().lock();
441	>	lock.writeLock().unlock();
442	>	}});
443
472	–	t1.start();
473	–	t2.start();
444		lock.writeLock().lock();
445		lock.writeLock().unlock();
446		Thread.sleep(SHORT_DELAY_MS);
447		lock.writeLock().lock();
448		lock.writeLock().unlock();
449		lock.writeLock().unlock();
450	<	t1.join(MEDIUM_DELAY_MS);
451	<	t2.join(MEDIUM_DELAY_MS);
482	<	assertTrue(!t1.isAlive());
483	<	assertTrue(!t2.isAlive());
450	>	awaitTermination(t1, LONG_DELAY_MS);
451	>	awaitTermination(t2, LONG_DELAY_MS);
452		}
453
454
#	Line 488 | Line 456 | public class ReentrantReadWriteLockTest
456		* Fair Read trylock succeeds if write locked by current thread
457		*/
458		public void testReadHoldingWriteLockFair() {
459	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
460	<	lock.writeLock().lock();
459	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
460	>	lock.writeLock().lock();
461		assertTrue(lock.readLock().tryLock());
462		lock.readLock().unlock();
463		lock.writeLock().unlock();
#	Line 500 | Line 468 | public class ReentrantReadWriteLockTest
468		* other threads are waiting for readlock
469		*/
470		public void testReadHoldingWriteLockFair2() throws InterruptedException {
471	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
472	<	lock.writeLock().lock();
473	<	Thread t1 = new Thread(new Runnable() {
474	<	public void run() {
475	<	lock.readLock().lock();
476	<	lock.readLock().unlock();
477	<	}
478	<	});
479	<	Thread t2 = new Thread(new Runnable() {
480	<	public void run() {
481	<	lock.readLock().lock();
482	<	lock.readLock().unlock();
515	<	}
516	<	});
471	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
472	>	lock.writeLock().lock();
473	>	Thread t1 = newStartedThread(new CheckedRunnable() {
474	>	public void realRun() {
475	>	lock.readLock().lock();
476	>	lock.readLock().unlock();
477	>	}});
478	>	Thread t2 = newStartedThread(new CheckedRunnable() {
479	>	public void realRun() {
480	>	lock.readLock().lock();
481	>	lock.readLock().unlock();
482	>	}});
483
518	–	t1.start();
519	–	t2.start();
484		lock.readLock().lock();
485		lock.readLock().unlock();
486		Thread.sleep(SHORT_DELAY_MS);
487		lock.readLock().lock();
488		lock.readLock().unlock();
489		lock.writeLock().unlock();
490	<	t1.join(MEDIUM_DELAY_MS);
491	<	t2.join(MEDIUM_DELAY_MS);
528	<	assertTrue(!t1.isAlive());
529	<	assertTrue(!t2.isAlive());
490	>	awaitTermination(t1, LONG_DELAY_MS);
491	>	awaitTermination(t2, LONG_DELAY_MS);
492		}
493
494
#	Line 535 | Line 497 | public class ReentrantReadWriteLockTest
497		* other threads are waiting for writelock
498		*/
499		public void testReadHoldingWriteLockFair3() throws InterruptedException {
500	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
501	<	lock.writeLock().lock();
502	<	Thread t1 = new Thread(new Runnable() {
503	<	public void run() {
504	<	lock.writeLock().lock();
505	<	lock.writeLock().unlock();
506	<	}
507	<	});
508	<	Thread t2 = new Thread(new Runnable() {
509	<	public void run() {
510	<	lock.writeLock().lock();
511	<	lock.writeLock().unlock();
550	<	}
551	<	});
500	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
501	>	lock.writeLock().lock();
502	>	Thread t1 = newStartedThread(new CheckedRunnable() {
503	>	public void realRun() {
504	>	lock.writeLock().lock();
505	>	lock.writeLock().unlock();
506	>	}});
507	>	Thread t2 = newStartedThread(new CheckedRunnable() {
508	>	public void realRun() {
509	>	lock.writeLock().lock();
510	>	lock.writeLock().unlock();
511	>	}});
512
553	–	t1.start();
554	–	t2.start();
513		lock.readLock().lock();
514		lock.readLock().unlock();
515		Thread.sleep(SHORT_DELAY_MS);
516		lock.readLock().lock();
517		lock.readLock().unlock();
518		lock.writeLock().unlock();
519	<	t1.join(MEDIUM_DELAY_MS);
520	<	t2.join(MEDIUM_DELAY_MS);
563	<	assertTrue(!t1.isAlive());
564	<	assertTrue(!t2.isAlive());
519	>	awaitTermination(t1, LONG_DELAY_MS);
520	>	awaitTermination(t2, LONG_DELAY_MS);
521		}
522
523
#	Line 570 | Line 526 | public class ReentrantReadWriteLockTest
526		* other threads are waiting for writelock
527		*/
528		public void testWriteHoldingWriteLockFair4() throws InterruptedException {
529	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
530	<	lock.writeLock().lock();
531	<	Thread t1 = new Thread(new Runnable() {
532	<	public void run() {
533	<	lock.writeLock().lock();
534	<	lock.writeLock().unlock();
535	<	}
536	<	});
537	<	Thread t2 = new Thread(new Runnable() {
538	<	public void run() {
539	<	lock.writeLock().lock();
540	<	lock.writeLock().unlock();
585	<	}
586	<	});
529	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
530	>	lock.writeLock().lock();
531	>	Thread t1 = newStartedThread(new CheckedRunnable() {
532	>	public void realRun() {
533	>	lock.writeLock().lock();
534	>	lock.writeLock().unlock();
535	>	}});
536	>	Thread t2 = newStartedThread(new CheckedRunnable() {
537	>	public void realRun() {
538	>	lock.writeLock().lock();
539	>	lock.writeLock().unlock();
540	>	}});
541
588	–	t1.start();
589	–	t2.start();
542		Thread.sleep(SHORT_DELAY_MS);
543		assertTrue(lock.isWriteLockedByCurrentThread());
544	<	assertTrue(lock.getWriteHoldCount() == 1);
544	>	assertEquals(1, lock.getWriteHoldCount());
545		lock.writeLock().lock();
546	<	assertTrue(lock.getWriteHoldCount() == 2);
546	>	assertEquals(2, lock.getWriteHoldCount());
547		lock.writeLock().unlock();
548		lock.writeLock().lock();
549		lock.writeLock().unlock();
550		lock.writeLock().unlock();
551	<	t1.join(MEDIUM_DELAY_MS);
552	<	t2.join(MEDIUM_DELAY_MS);
601	<	assertTrue(!t1.isAlive());
602	<	assertTrue(!t2.isAlive());
551	>	awaitTermination(t1, LONG_DELAY_MS);
552	>	awaitTermination(t2, LONG_DELAY_MS);
553		}
554
555
#	Line 607 | Line 557 | public class ReentrantReadWriteLockTest
557		* Read tryLock succeeds if readlocked but not writelocked
558		*/
559		public void testTryLockWhenReadLocked() throws InterruptedException {
560	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
561	<	lock.readLock().lock();
562	<	Thread t = new Thread(new Runnable() {
563	<	public void run() {
564	<	threadAssertTrue(lock.readLock().tryLock());
565	<	lock.readLock().unlock();
566	<	}
617	<	});
560	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
561	>	lock.readLock().lock();
562	>	Thread t = newStartedThread(new CheckedRunnable() {
563	>	public void realRun() {
564	>	assertTrue(lock.readLock().tryLock());
565	>	lock.readLock().unlock();
566	>	}});
567
568	<	t.start();
620	<	t.join();
568	>	awaitTermination(t, LONG_DELAY_MS);
569		lock.readLock().unlock();
570		}
571
624	–
625	–
572		/**
573		* write tryLock fails when readlocked
574		*/
575		public void testWriteTryLockWhenReadLocked() throws InterruptedException {
576	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
577	<	lock.readLock().lock();
578	<	Thread t = new Thread(new Runnable() {
579	<	public void run() {
580	<	threadAssertFalse(lock.writeLock().tryLock());
581	<	}
636	<	});
576	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
577	>	lock.readLock().lock();
578	>	Thread t = newStartedThread(new CheckedRunnable() {
579	>	public void realRun() {
580	>	assertFalse(lock.writeLock().tryLock());
581	>	}});
582
583	<	t.start();
639	<	t.join();
583	>	awaitTermination(t, LONG_DELAY_MS);
584		lock.readLock().unlock();
585		}
586
#	Line 645 | Line 589 | public class ReentrantReadWriteLockTest
589		* Fair Read tryLock succeeds if readlocked but not writelocked
590		*/
591		public void testTryLockWhenReadLockedFair() throws InterruptedException {
592	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
593	<	lock.readLock().lock();
594	<	Thread t = new Thread(new Runnable() {
595	<	public void run() {
596	<	threadAssertTrue(lock.readLock().tryLock());
597	<	lock.readLock().unlock();
598	<	}
655	<	});
592	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
593	>	lock.readLock().lock();
594	>	Thread t = newStartedThread(new CheckedRunnable() {
595	>	public void realRun() {
596	>	assertTrue(lock.readLock().tryLock());
597	>	lock.readLock().unlock();
598	>	}});
599
600	<	t.start();
658	<	t.join();
600	>	awaitTermination(t, LONG_DELAY_MS);
601		lock.readLock().unlock();
602		}
603
#	Line 665 | Line 607 | public class ReentrantReadWriteLockTest
607		* Fair write tryLock fails when readlocked
608		*/
609		public void testWriteTryLockWhenReadLockedFair() throws InterruptedException {
610	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
611	<	lock.readLock().lock();
612	<	Thread t = new Thread(new Runnable() {
613	<	public void run() {
614	<	threadAssertFalse(lock.writeLock().tryLock());
615	<	}
674	<	});
610	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
611	>	lock.readLock().lock();
612	>	Thread t = newStartedThread(new CheckedRunnable() {
613	>	public void realRun() {
614	>	assertFalse(lock.writeLock().tryLock());
615	>	}});
616
617	<	t.start();
677	<	t.join();
617	>	awaitTermination(t, LONG_DELAY_MS);
618		lock.readLock().unlock();
619		}
620
#	Line 684 | Line 624 | public class ReentrantReadWriteLockTest
624		* write timed tryLock times out if locked
625		*/
626		public void testWriteTryLock_Timeout() throws InterruptedException {
627	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
628	<	lock.writeLock().lock();
629	<	Thread t = new Thread(new CheckedRunnable() {
627	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
628	>	lock.writeLock().lock();
629	>	Thread t = newStartedThread(new CheckedRunnable() {
630		public void realRun() throws InterruptedException {
631	<	threadAssertFalse(lock.writeLock().tryLock(1, TimeUnit.MILLISECONDS));
631	>	assertFalse(lock.writeLock().tryLock(1, MILLISECONDS));
632		}});
633
634	<	t.start();
635	<	t.join();
634	>	awaitTermination(t, LONG_DELAY_MS);
635	>	assertTrue(lock.writeLock().isHeldByCurrentThread());
636		lock.writeLock().unlock();
637		}
638
#	Line 700 | Line 640 | public class ReentrantReadWriteLockTest
640		* read timed tryLock times out if write-locked
641		*/
642		public void testReadTryLock_Timeout() throws InterruptedException {
643	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
644	<	lock.writeLock().lock();
645	<	Thread t = new Thread(new CheckedRunnable() {
643	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
644	>	lock.writeLock().lock();
645	>	Thread t = newStartedThread(new CheckedRunnable() {
646		public void realRun() throws InterruptedException {
647	<	threadAssertFalse(lock.readLock().tryLock(1, TimeUnit.MILLISECONDS));
647	>	assertFalse(lock.readLock().tryLock(1, MILLISECONDS));
648		}});
649
650	<	t.start();
651	<	t.join();
650	>	awaitTermination(t, LONG_DELAY_MS);
651	>	assertTrue(lock.writeLock().isHeldByCurrentThread());
652		lock.writeLock().unlock();
653		}
654
#	Line 717 | Line 657 | public class ReentrantReadWriteLockTest
657		* write lockInterruptibly succeeds if lock free else is interruptible
658		*/
659		public void testWriteLockInterruptibly() throws InterruptedException {
660	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
660	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
661		lock.writeLock().lockInterruptibly();
662	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
662	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
663		public void realRun() throws InterruptedException {
664		lock.writeLock().lockInterruptibly();
665		}});
666
727	–	t.start();
667		Thread.sleep(SHORT_DELAY_MS);
668		t.interrupt();
669	<	Thread.sleep(SHORT_DELAY_MS);
670	<	t.join();
732	<	lock.writeLock().unlock();
669	>	awaitTermination(t, LONG_DELAY_MS);
670	>	releaseLock(lock.writeLock());
671		}
672
673		/**
674	<	*  read lockInterruptibly succeeds if lock free else is interruptible
674	>	* read lockInterruptibly succeeds if lock free else is interruptible
675		*/
676		public void testReadLockInterruptibly() throws InterruptedException {
677	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
677	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
678		lock.writeLock().lockInterruptibly();
679	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
679	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
680		public void realRun() throws InterruptedException {
681		lock.readLock().lockInterruptibly();
682		}});
683
746	–	t.start();
684		Thread.sleep(SHORT_DELAY_MS);
685		t.interrupt();
686	<	t.join();
687	<	lock.writeLock().unlock();
686	>	awaitTermination(t, LONG_DELAY_MS);
687	>	releaseLock(lock.writeLock());
688		}
689
690		/**
691		* Calling await without holding lock throws IllegalMonitorStateException
692		*/
693		public void testAwait_IllegalMonitor() throws InterruptedException {
694	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
694	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
695		final Condition c = lock.writeLock().newCondition();
696		try {
697		c.await();
#	Line 766 | Line 703 | public class ReentrantReadWriteLockTest
703		* Calling signal without holding lock throws IllegalMonitorStateException
704		*/
705		public void testSignal_IllegalMonitor() {
706	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
706	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
707		final Condition c = lock.writeLock().newCondition();
708		try {
709		c.signal();
#	Line 778 | Line 715 | public class ReentrantReadWriteLockTest
715		* awaitNanos without a signal times out
716		*/
717		public void testAwaitNanos_Timeout() throws InterruptedException {
718	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
718	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
719		final Condition c = lock.writeLock().newCondition();
720
721		lock.writeLock().lock();
#	Line 789 | Line 726 | public class ReentrantReadWriteLockTest
726
727
728		/**
729	<	*  timed await without a signal times out
729	>	* timed await without a signal times out
730		*/
731	<	public void testAwait_Timeout() {
732	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
731	>	public void testAwait_Timeout() throws InterruptedException {
732	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
733		final Condition c = lock.writeLock().newCondition();
734		lock.writeLock().lock();
735	+	assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS));
736		lock.writeLock().unlock();
737		}
738
739		/**
740		* awaitUntil without a signal times out
741		*/
742	<	public void testAwaitUntil_Timeout() {
743	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
742	>	public void testAwaitUntil_Timeout() throws InterruptedException {
743	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
744		final Condition c = lock.writeLock().newCondition();
745		lock.writeLock().lock();
746		java.util.Date d = new java.util.Date();
747	+	assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
748		lock.writeLock().unlock();
749		}
750
#	Line 813 | Line 752 | public class ReentrantReadWriteLockTest
752		* await returns when signalled
753		*/
754		public void testAwait() throws InterruptedException {
755	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
755	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
756		final Condition c = lock.writeLock().newCondition();
757	<	Thread t = new Thread(new CheckedRunnable() {
757	>	Thread t = newStartedThread(new CheckedRunnable() {
758		public void realRun() throws InterruptedException {
759		lock.writeLock().lock();
760		c.await();
761		lock.writeLock().unlock();
762		}});
763
825	–	t.start();
764		Thread.sleep(SHORT_DELAY_MS);
765		lock.writeLock().lock();
766		c.signal();
767		lock.writeLock().unlock();
768	<	t.join(SHORT_DELAY_MS);
831	<	assertFalse(t.isAlive());
768	>	awaitTermination(t, LONG_DELAY_MS);
769		}
770
771		/** A helper class for uninterruptible wait tests */
#	Line 881 | Line 818 | public class ReentrantReadWriteLockTest
818		lock.writeLock().unlock();
819		}
820
821	<	thread.join();
821	>	awaitTermination(thread, LONG_DELAY_MS);
822		assertTrue(thread.interrupted);
886	–	assertFalse(thread.isAlive());
823		}
824
825		/**
826		* await is interruptible
827		*/
828		public void testAwait_Interrupt() throws InterruptedException {
829	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
829	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
830		final Condition c = lock.writeLock().newCondition();
831	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
831	>	final CountDownLatch locked = new CountDownLatch(1);
832	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
833		public void realRun() throws InterruptedException {
834		lock.writeLock().lock();
835	<	c.await();
836	<	lock.writeLock().unlock();
835	>	assertTrue(lock.isWriteLocked());
836	>	locked.countDown();
837	>	try { c.await(); }
838	>	finally { lock.writeLock().unlock(); }
839		}});
840
841	<	t.start();
842	<	Thread.sleep(SHORT_DELAY_MS);
841	>	locked.await();
842	>	while (lock.isWriteLocked())
843	>	Thread.yield();
844		t.interrupt();
845	<	t.join(SHORT_DELAY_MS);
846	<	assertFalse(t.isAlive());
845	>	awaitTermination(t, LONG_DELAY_MS);
846	>	assertFalse(lock.isWriteLocked());
847		}
848
849		/**
850		* awaitNanos is interruptible
851		*/
852		public void testAwaitNanos_Interrupt() throws InterruptedException {
853	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
853	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
854		final Condition c = lock.writeLock().newCondition();
855	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
855	>	final CountDownLatch locked = new CountDownLatch(1);
856	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
857		public void realRun() throws InterruptedException {
858		lock.writeLock().lock();
859	<	c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
860	<	lock.writeLock().unlock();
859	>	assertTrue(lock.isWriteLocked());
860	>	locked.countDown();
861	>	try { c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS)); }
862	>	finally { lock.writeLock().unlock(); }
863		}});
864
865	<	t.start();
866	<	Thread.sleep(SHORT_DELAY_MS);
865	>	locked.await();
866	>	while (lock.isWriteLocked())
867	>	Thread.yield();
868		t.interrupt();
869	<	t.join(SHORT_DELAY_MS);
870	<	assertFalse(t.isAlive());
869	>	awaitTermination(t, LONG_DELAY_MS);
870	>	assertFalse(lock.isWriteLocked());
871		}
872
873		/**
874		* awaitUntil is interruptible
875		*/
876		public void testAwaitUntil_Interrupt() throws InterruptedException {
877	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
877	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
878		final Condition c = lock.writeLock().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.writeLock().lock();
883	+	assertTrue(lock.isWriteLocked());
884	+	locked.countDown();
885		java.util.Date d = new java.util.Date();
886	<	c.awaitUntil(new java.util.Date(d.getTime() + 10000));
887	<	lock.writeLock().unlock();
886	>	try { c.awaitUntil(new java.util.Date(d.getTime() + 10000)); }
887	>	finally { lock.writeLock().unlock(); }
888		}});
889
890	<	t.start();
891	<	Thread.sleep(SHORT_DELAY_MS);
890	>	locked.await();
891	>	while (lock.isWriteLocked())
892	>	Thread.yield();
893		t.interrupt();
894	<	t.join(SHORT_DELAY_MS);
895	<	assertFalse(t.isAlive());
894	>	awaitTermination(t, LONG_DELAY_MS);
895	>	assertFalse(lock.isWriteLocked());
896		}
897
898		/**
899		* signalAll wakes up all threads
900		*/
901		public void testSignalAll() throws InterruptedException {
902	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
902	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
903		final Condition c = lock.writeLock().newCondition();
904	<	Thread t1 = new Thread(new CheckedRunnable() {
904	>	Thread t1 = newStartedThread(new CheckedRunnable() {
905		public void realRun() throws InterruptedException {
906		lock.writeLock().lock();
907		c.await();
908		lock.writeLock().unlock();
909		}});
910
911	<	Thread t2 = new Thread(new CheckedRunnable() {
911	>	Thread t2 = newStartedThread(new CheckedRunnable() {
912		public void realRun() throws InterruptedException {
913		lock.writeLock().lock();
914		c.await();
915		lock.writeLock().unlock();
916		}});
917
970	–	t1.start();
971	–	t2.start();
918		Thread.sleep(SHORT_DELAY_MS);
919		lock.writeLock().lock();
920		c.signalAll();
921		lock.writeLock().unlock();
922	<	t1.join(SHORT_DELAY_MS);
923	<	t2.join(SHORT_DELAY_MS);
978	<	assertFalse(t1.isAlive());
979	<	assertFalse(t2.isAlive());
922	>	awaitTermination(t1, LONG_DELAY_MS);
923	>	awaitTermination(t2, LONG_DELAY_MS);
924		}
925
926		/**
#	Line 1003 | Line 947 | public class ReentrantReadWriteLockTest
947		* hasQueuedThreads reports whether there are waiting threads
948		*/
949		public void testhasQueuedThreads() throws InterruptedException {
950	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
950	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
951		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
952		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
953		assertFalse(lock.hasQueuedThreads());
#	Line 1020 | Line 964 | public class ReentrantReadWriteLockTest
964		lock.writeLock().unlock();
965		Thread.sleep(SHORT_DELAY_MS);
966		assertFalse(lock.hasQueuedThreads());
967	<	t1.join();
968	<	t2.join();
967	>	awaitTermination(t1, LONG_DELAY_MS);
968	>	awaitTermination(t2, LONG_DELAY_MS);
969		}
970
971		/**
972		* hasQueuedThread(null) throws NPE
973		*/
974		public void testHasQueuedThreadNPE() {
975	<	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
975	>	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
976		try {
977		sync.hasQueuedThread(null);
978		shouldThrow();
#	Line 1039 | Line 983 | public class ReentrantReadWriteLockTest
983		* hasQueuedThread reports whether a thread is queued.
984		*/
985		public void testHasQueuedThread() throws InterruptedException {
986	<	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
986	>	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
987		Thread t1 = new Thread(new InterruptedLockRunnable(sync));
988		Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
989		assertFalse(sync.hasQueuedThread(t1));
#	Line 1061 | Line 1005 | public class ReentrantReadWriteLockTest
1005		assertFalse(sync.hasQueuedThread(t1));
1006		Thread.sleep(SHORT_DELAY_MS);
1007		assertFalse(sync.hasQueuedThread(t2));
1008	<	t1.join();
1009	<	t2.join();
1008	>	awaitTermination(t1, LONG_DELAY_MS);
1009	>	awaitTermination(t2, LONG_DELAY_MS);
1010		}
1011
1012
#	Line 1070 | Line 1014 | public class ReentrantReadWriteLockTest
1014		* getQueueLength reports number of waiting threads
1015		*/
1016		public void testGetQueueLength() throws InterruptedException {
1017	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1017	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1018		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1019		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1020		assertEquals(0, lock.getQueueLength());
#	Line 1087 | Line 1031 | public class ReentrantReadWriteLockTest
1031		lock.writeLock().unlock();
1032		Thread.sleep(SHORT_DELAY_MS);
1033		assertEquals(0, lock.getQueueLength());
1034	<	t1.join();
1035	<	t2.join();
1034	>	awaitTermination(t1, LONG_DELAY_MS);
1035	>	awaitTermination(t2, LONG_DELAY_MS);
1036		}
1037
1038		/**
1039		* getQueuedThreads includes waiting threads
1040		*/
1041		public void testGetQueuedThreads() throws InterruptedException {
1042	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1042	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1043		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1044		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1045		assertTrue(lock.getQueuedThreads().isEmpty());
#	Line 1115 | Line 1059 | public class ReentrantReadWriteLockTest
1059		lock.writeLock().unlock();
1060		Thread.sleep(SHORT_DELAY_MS);
1061		assertTrue(lock.getQueuedThreads().isEmpty());
1062	<	t1.join();
1063	<	t2.join();
1062	>	awaitTermination(t1, LONG_DELAY_MS);
1063	>	awaitTermination(t2, LONG_DELAY_MS);
1064		}
1065
1066		/**
1067		* hasWaiters throws NPE if null
1068		*/
1069		public void testHasWaitersNPE() {
1070	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1070	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1071		try {
1072		lock.hasWaiters(null);
1073		shouldThrow();
#	Line 1134 | Line 1078 | public class ReentrantReadWriteLockTest
1078		* getWaitQueueLength throws NPE if null
1079		*/
1080		public void testGetWaitQueueLengthNPE() {
1081	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1081	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1082		try {
1083		lock.getWaitQueueLength(null);
1084		shouldThrow();
#	Line 1146 | Line 1090 | public class ReentrantReadWriteLockTest
1090		* getWaitingThreads throws NPE if null
1091		*/
1092		public void testGetWaitingThreadsNPE() {
1093	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1093	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1094		try {
1095		lock.getWaitingThreads(null);
1096		shouldThrow();
#	Line 1157 | Line 1101 | public class ReentrantReadWriteLockTest
1101		* hasWaiters throws IAE if not owned
1102		*/
1103		public void testHasWaitersIAE() {
1104	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1104	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1105		final Condition c = lock.writeLock().newCondition();
1106	<	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1106	>	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1107		try {
1108		lock2.hasWaiters(c);
1109		shouldThrow();
#	Line 1170 | Line 1114 | public class ReentrantReadWriteLockTest
1114		* hasWaiters throws IMSE if not locked
1115		*/
1116		public void testHasWaitersIMSE() {
1117	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1117	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1118		final Condition c = lock.writeLock().newCondition();
1119		try {
1120		lock.hasWaiters(c);
#	Line 1183 | Line 1127 | public class ReentrantReadWriteLockTest
1127		* getWaitQueueLength throws IAE if not owned
1128		*/
1129		public void testGetWaitQueueLengthIAE() {
1130	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1130	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1131		final Condition c = lock.writeLock().newCondition();
1132	<	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1132	>	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1133		try {
1134		lock2.getWaitQueueLength(c);
1135		shouldThrow();
#	Line 1196 | Line 1140 | public class ReentrantReadWriteLockTest
1140		* getWaitQueueLength throws IMSE if not locked
1141		*/
1142		public void testGetWaitQueueLengthIMSE() {
1143	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1143	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1144		final Condition c = lock.writeLock().newCondition();
1145		try {
1146		lock.getWaitQueueLength(c);
#	Line 1209 | Line 1153 | public class ReentrantReadWriteLockTest
1153		* getWaitingThreads throws IAE if not owned
1154		*/
1155		public void testGetWaitingThreadsIAE() {
1156	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1156	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1157		final Condition c = lock.writeLock().newCondition();
1158	<	final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
1158	>	final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
1159		try {
1160		lock2.getWaitingThreads(c);
1161		shouldThrow();
#	Line 1222 | Line 1166 | public class ReentrantReadWriteLockTest
1166		* getWaitingThreads throws IMSE if not locked
1167		*/
1168		public void testGetWaitingThreadsIMSE() {
1169	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1169	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1170		final Condition c = lock.writeLock().newCondition();
1171		try {
1172		lock.getWaitingThreads(c);
#	Line 1235 | Line 1179 | public class ReentrantReadWriteLockTest
1179		* hasWaiters returns true when a thread is waiting, else false
1180		*/
1181		public void testHasWaiters() throws InterruptedException {
1182	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1182	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1183		final Condition c = lock.writeLock().newCondition();
1184	<	Thread t = new Thread(new CheckedRunnable() {
1184	>	Thread t = newStartedThread(new CheckedRunnable() {
1185		public void realRun() throws InterruptedException {
1186		lock.writeLock().lock();
1187	<	threadAssertFalse(lock.hasWaiters(c));
1188	<	threadAssertEquals(0, lock.getWaitQueueLength(c));
1187	>	assertFalse(lock.hasWaiters(c));
1188	>	assertEquals(0, lock.getWaitQueueLength(c));
1189		c.await();
1190		lock.writeLock().unlock();
1191		}});
1192
1249	–	t.start();
1193		Thread.sleep(SHORT_DELAY_MS);
1194		lock.writeLock().lock();
1195		assertTrue(lock.hasWaiters(c));
#	Line 1258 | Line 1201 | public class ReentrantReadWriteLockTest
1201		assertFalse(lock.hasWaiters(c));
1202		assertEquals(0, lock.getWaitQueueLength(c));
1203		lock.writeLock().unlock();
1204	<	t.join(SHORT_DELAY_MS);
1262	<	assertFalse(t.isAlive());
1204	>	awaitTermination(t, LONG_DELAY_MS);
1205		}
1206
1207		/**
1208		* getWaitQueueLength returns number of waiting threads
1209		*/
1210		public void testGetWaitQueueLength() throws InterruptedException {
1211	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1211	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1212		final Condition c = lock.writeLock().newCondition();
1213	<	Thread t = new Thread(new CheckedRunnable() {
1213	>	Thread t = newStartedThread(new CheckedRunnable() {
1214		public void realRun() throws InterruptedException {
1215		lock.writeLock().lock();
1216	<	threadAssertFalse(lock.hasWaiters(c));
1217	<	threadAssertEquals(0, lock.getWaitQueueLength(c));
1216	>	assertFalse(lock.hasWaiters(c));
1217	>	assertEquals(0, lock.getWaitQueueLength(c));
1218		c.await();
1219		lock.writeLock().unlock();
1220		}});
1221
1280	–	t.start();
1222		Thread.sleep(SHORT_DELAY_MS);
1223		lock.writeLock().lock();
1224		assertTrue(lock.hasWaiters(c));
#	Line 1289 | Line 1230 | public class ReentrantReadWriteLockTest
1230		assertFalse(lock.hasWaiters(c));
1231		assertEquals(0, lock.getWaitQueueLength(c));
1232		lock.writeLock().unlock();
1233	<	t.join(SHORT_DELAY_MS);
1293	<	assertFalse(t.isAlive());
1233	>	awaitTermination(t, LONG_DELAY_MS);
1234		}
1235
1236
#	Line 1298 | Line 1238 | public class ReentrantReadWriteLockTest
1238		* getWaitingThreads returns only and all waiting threads
1239		*/
1240		public void testGetWaitingThreads() throws InterruptedException {
1241	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1241	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1242		final Condition c = lock.writeLock().newCondition();
1243	<	Thread t1 = new Thread(new CheckedRunnable() {
1243	>	Thread t1 = new Thread(new CheckedRunnable() {
1244		public void realRun() throws InterruptedException {
1245		lock.writeLock().lock();
1246	<	threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
1246	>	assertTrue(lock.getWaitingThreads(c).isEmpty());
1247		c.await();
1248		lock.writeLock().unlock();
1249		}});
1250
1251	<	Thread t2 = new Thread(new CheckedRunnable() {
1251	>	Thread t2 = new Thread(new CheckedRunnable() {
1252		public void realRun() throws InterruptedException {
1253		lock.writeLock().lock();
1254	<	threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
1254	>	assertFalse(lock.getWaitingThreads(c).isEmpty());
1255		c.await();
1256		lock.writeLock().unlock();
1257		}});
#	Line 1334 | Line 1274 | public class ReentrantReadWriteLockTest
1274		assertFalse(lock.hasWaiters(c));
1275		assertTrue(lock.getWaitingThreads(c).isEmpty());
1276		lock.writeLock().unlock();
1277	<	t1.join(SHORT_DELAY_MS);
1278	<	t2.join(SHORT_DELAY_MS);
1339	<	assertFalse(t1.isAlive());
1340	<	assertFalse(t2.isAlive());
1277	>	awaitTermination(t1, LONG_DELAY_MS);
1278	>	awaitTermination(t2, LONG_DELAY_MS);
1279		}
1280
1281		/**

Diff Legend

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