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

Comparing jsr166/src/test/tck/ReentrantLockTest.java (file contents):
Revision 1.45 by jsr166, Sat May 7 19:03:26 2011 UTC vs.
Revision 1.70 by jsr166, Sun Sep 22 01:59:57 2019 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 import junit.framework.*;
10 import java.util.concurrent.locks.*;
11 import java.util.concurrent.*;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
13 import java.util.*;
14 import java.io.*;
10  
11 + import java.util.ArrayList;
12 + import java.util.Arrays;
13 + import java.util.Collection;
14 + import java.util.HashSet;
15 + import java.util.concurrent.Callable;
16 + import java.util.concurrent.CountDownLatch;
17 + import java.util.concurrent.CyclicBarrier;
18 + import java.util.concurrent.ThreadLocalRandom;
19 + import java.util.concurrent.atomic.AtomicBoolean;
20 + import java.util.concurrent.locks.Condition;
21 + import java.util.concurrent.locks.Lock;
22 + import java.util.concurrent.locks.ReentrantLock;
23 +
24 + import junit.framework.Test;
25 + import junit.framework.TestSuite;
26 +
27 + @SuppressWarnings("WaitNotInLoop") // we implement spurious-wakeup freedom
28   public class ReentrantLockTest extends JSR166TestCase {
29      public static void main(String[] args) {
30 <        junit.textui.TestRunner.run(suite());
30 >        main(suite(), args);
31      }
32      public static Test suite() {
33          return new TestSuite(ReentrantLockTest.class);
34      }
35  
36      /**
37 <     * A runnable calling lockInterruptibly
37 >     * A checked runnable calling lockInterruptibly
38       */
39      class InterruptibleLockRunnable extends CheckedRunnable {
40          final ReentrantLock lock;
41 <        InterruptibleLockRunnable(ReentrantLock l) { lock = l; }
41 >        InterruptibleLockRunnable(ReentrantLock lock) { this.lock = lock; }
42          public void realRun() throws InterruptedException {
43              lock.lockInterruptibly();
44          }
45      }
46  
47      /**
48 <     * A runnable calling lockInterruptibly that expects to be
48 >     * A checked runnable calling lockInterruptibly that expects to be
49       * interrupted
50       */
51      class InterruptedLockRunnable extends CheckedInterruptedRunnable {
52          final ReentrantLock lock;
53 <        InterruptedLockRunnable(ReentrantLock l) { lock = l; }
53 >        InterruptedLockRunnable(ReentrantLock lock) { this.lock = lock; }
54          public void realRun() throws InterruptedException {
55              lock.lockInterruptibly();
56          }
# Line 65 | Line 77 | public class ReentrantLockTest extends J
77       * Releases write lock, checking that it had a hold count of 1.
78       */
79      void releaseLock(PublicReentrantLock lock) {
80 <        assertLockedBy(lock, Thread.currentThread());
80 >        assertLockedByMoi(lock);
81          lock.unlock();
82          assertFalse(lock.isHeldByCurrentThread());
83          assertNotLocked(lock);
# Line 82 | Line 94 | public class ReentrantLockTest extends J
94              Thread.yield();
95          }
96          assertTrue(t.isAlive());
97 <        assertTrue(lock.getOwner() != t);
97 >        assertNotSame(t, lock.getOwner());
98      }
99  
100      /**
# Line 108 | Line 120 | public class ReentrantLockTest extends J
120      }
121  
122      /**
123 +     * Checks that lock is locked by the current thread.
124 +     */
125 +    void assertLockedByMoi(PublicReentrantLock lock) {
126 +        assertLockedBy(lock, Thread.currentThread());
127 +    }
128 +
129 +    /**
130       * Checks that condition c has no waiters.
131       */
132      void assertHasNoWaiters(PublicReentrantLock lock, Condition c) {
# Line 129 | Line 148 | public class ReentrantLockTest extends J
148          lock.unlock();
149      }
150  
151 +    enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
152 +
153 +    static AwaitMethod randomAwaitMethod() {
154 +        AwaitMethod[] awaitMethods = AwaitMethod.values();
155 +        return awaitMethods[ThreadLocalRandom.current().nextInt(awaitMethods.length)];
156 +    }
157 +
158 +    /**
159 +     * Awaits condition "indefinitely" using the specified AwaitMethod.
160 +     */
161 +    void await(Condition c, AwaitMethod awaitMethod)
162 +            throws InterruptedException {
163 +        long timeoutMillis = 2 * LONG_DELAY_MS;
164 +        switch (awaitMethod) {
165 +        case await:
166 +            c.await();
167 +            break;
168 +        case awaitTimed:
169 +            assertTrue(c.await(timeoutMillis, MILLISECONDS));
170 +            break;
171 +        case awaitNanos:
172 +            long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
173 +            long nanosRemaining = c.awaitNanos(timeoutNanos);
174 +            assertTrue(nanosRemaining > timeoutNanos / 2);
175 +            assertTrue(nanosRemaining <= timeoutNanos);
176 +            break;
177 +        case awaitUntil:
178 +            assertTrue(c.awaitUntil(delayedDate(timeoutMillis)));
179 +            break;
180 +        default:
181 +            throw new AssertionError();
182 +        }
183 +    }
184 +
185      /**
186       * Constructor sets given fairness, and is in unlocked state
187       */
# Line 151 | Line 204 | public class ReentrantLockTest extends J
204      /**
205       * locking an unlocked lock succeeds
206       */
207 <    public void testLock() {
208 <        PublicReentrantLock lock = new PublicReentrantLock();
207 >    public void testLock()      { testLock(false); }
208 >    public void testLock_fair() { testLock(true); }
209 >    public void testLock(boolean fair) {
210 >        PublicReentrantLock lock = new PublicReentrantLock(fair);
211          lock.lock();
212 <        assertLockedBy(lock, Thread.currentThread());
158 <        releaseLock(lock);
159 <    }
160 <
161 <    /**
162 <     * locking an unlocked fair lock succeeds
163 <     */
164 <    public void testFairLock() {
165 <        PublicReentrantLock lock = new PublicReentrantLock(true);
166 <        lock.lock();
167 <        assertLockedBy(lock, Thread.currentThread());
212 >        assertLockedByMoi(lock);
213          releaseLock(lock);
214      }
215  
216      /**
217       * Unlocking an unlocked lock throws IllegalMonitorStateException
218       */
219 <    public void testUnlock_IllegalMonitorStateException() {
220 <        ReentrantLock lock = new ReentrantLock();
219 >    public void testUnlock_IMSE()      { testUnlock_IMSE(false); }
220 >    public void testUnlock_IMSE_fair() { testUnlock_IMSE(true); }
221 >    public void testUnlock_IMSE(boolean fair) {
222 >        final ReentrantLock lock = new ReentrantLock(fair);
223          try {
224              lock.unlock();
225              shouldThrow();
# Line 182 | Line 229 | public class ReentrantLockTest extends J
229      /**
230       * tryLock on an unlocked lock succeeds
231       */
232 <    public void testTryLock() {
233 <        PublicReentrantLock lock = new PublicReentrantLock();
232 >    public void testTryLock()      { testTryLock(false); }
233 >    public void testTryLock_fair() { testTryLock(true); }
234 >    public void testTryLock(boolean fair) {
235 >        PublicReentrantLock lock = new PublicReentrantLock(fair);
236          assertTrue(lock.tryLock());
237 <        assertLockedBy(lock, Thread.currentThread());
237 >        assertLockedByMoi(lock);
238 >        assertTrue(lock.tryLock());
239 >        assertLockedByMoi(lock);
240 >        lock.unlock();
241          releaseLock(lock);
242      }
243  
244      /**
245       * hasQueuedThreads reports whether there are waiting threads
246       */
247 <    public void testHasQueuedThreads() throws InterruptedException {
248 <        final PublicReentrantLock lock = new PublicReentrantLock();
247 >    public void testHasQueuedThreads()      { testHasQueuedThreads(false); }
248 >    public void testHasQueuedThreads_fair() { testHasQueuedThreads(true); }
249 >    public void testHasQueuedThreads(boolean fair) {
250 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
251          Thread t1 = new Thread(new InterruptedLockRunnable(lock));
252          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
253          assertFalse(lock.hasQueuedThreads());
# Line 216 | Line 270 | public class ReentrantLockTest extends J
270      /**
271       * getQueueLength reports number of waiting threads
272       */
273 <    public void testGetQueueLength() throws InterruptedException {
274 <        final PublicReentrantLock lock = new PublicReentrantLock();
275 <        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
276 <        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
223 <        assertEquals(0, lock.getQueueLength());
224 <        lock.lock();
225 <        t1.start();
226 <        waitForQueuedThread(lock, t1);
227 <        assertEquals(1, lock.getQueueLength());
228 <        t2.start();
229 <        waitForQueuedThread(lock, t2);
230 <        assertEquals(2, lock.getQueueLength());
231 <        t1.interrupt();
232 <        awaitTermination(t1);
233 <        assertEquals(1, lock.getQueueLength());
234 <        lock.unlock();
235 <        awaitTermination(t2);
236 <        assertEquals(0, lock.getQueueLength());
237 <    }
238 <
239 <    /**
240 <     * getQueueLength reports number of waiting threads
241 <     */
242 <    public void testGetQueueLength_fair() throws InterruptedException {
243 <        final PublicReentrantLock lock = new PublicReentrantLock(true);
273 >    public void testGetQueueLength()      { testGetQueueLength(false); }
274 >    public void testGetQueueLength_fair() { testGetQueueLength(true); }
275 >    public void testGetQueueLength(boolean fair) {
276 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
277          Thread t1 = new Thread(new InterruptedLockRunnable(lock));
278          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
279          assertEquals(0, lock.getQueueLength());
# Line 262 | Line 295 | public class ReentrantLockTest extends J
295      /**
296       * hasQueuedThread(null) throws NPE
297       */
298 <    public void testHasQueuedThreadNPE() {
299 <        final ReentrantLock lock = new ReentrantLock();
298 >    public void testHasQueuedThreadNPE()      { testHasQueuedThreadNPE(false); }
299 >    public void testHasQueuedThreadNPE_fair() { testHasQueuedThreadNPE(true); }
300 >    public void testHasQueuedThreadNPE(boolean fair) {
301 >        final ReentrantLock lock = new ReentrantLock(fair);
302          try {
303              lock.hasQueuedThread(null);
304              shouldThrow();
# Line 271 | Line 306 | public class ReentrantLockTest extends J
306      }
307  
308      /**
309 <     * hasQueuedThread reports whether a thread is queued.
309 >     * hasQueuedThread reports whether a thread is queued
310       */
311 <    public void testHasQueuedThread() throws InterruptedException {
312 <        final PublicReentrantLock lock = new PublicReentrantLock();
311 >    public void testHasQueuedThread()      { testHasQueuedThread(false); }
312 >    public void testHasQueuedThread_fair() { testHasQueuedThread(true); }
313 >    public void testHasQueuedThread(boolean fair) {
314 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
315          Thread t1 = new Thread(new InterruptedLockRunnable(lock));
316          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
317          assertFalse(lock.hasQueuedThread(t1));
# Line 301 | Line 338 | public class ReentrantLockTest extends J
338      /**
339       * getQueuedThreads includes waiting threads
340       */
341 <    public void testGetQueuedThreads() throws InterruptedException {
342 <        final PublicReentrantLock lock = new PublicReentrantLock();
341 >    public void testGetQueuedThreads()      { testGetQueuedThreads(false); }
342 >    public void testGetQueuedThreads_fair() { testGetQueuedThreads(true); }
343 >    public void testGetQueuedThreads(boolean fair) {
344 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
345          Thread t1 = new Thread(new InterruptedLockRunnable(lock));
346          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
347          assertTrue(lock.getQueuedThreads().isEmpty());
# Line 328 | Line 367 | public class ReentrantLockTest extends J
367      }
368  
369      /**
370 <     * timed tryLock is interruptible.
370 >     * timed tryLock is interruptible
371       */
372 <    public void testTryLock_Interrupted() throws InterruptedException {
373 <        final PublicReentrantLock lock = new PublicReentrantLock();
372 >    public void testTryLock_Interruptible()      { testTryLock_Interruptible(false); }
373 >    public void testTryLock_Interruptible_fair() { testTryLock_Interruptible(true); }
374 >    public void testTryLock_Interruptible(boolean fair) {
375 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
376          lock.lock();
377          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
378              public void realRun() throws InterruptedException {
# Line 347 | Line 388 | public class ReentrantLockTest extends J
388      /**
389       * tryLock on a locked lock fails
390       */
391 <    public void testTryLockWhenLocked() throws InterruptedException {
392 <        final PublicReentrantLock lock = new PublicReentrantLock();
391 >    public void testTryLockWhenLocked()      { testTryLockWhenLocked(false); }
392 >    public void testTryLockWhenLocked_fair() { testTryLockWhenLocked(true); }
393 >    public void testTryLockWhenLocked(boolean fair) {
394 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
395          lock.lock();
396          Thread t = newStartedThread(new CheckedRunnable() {
397              public void realRun() {
# Line 362 | Line 405 | public class ReentrantLockTest extends J
405      /**
406       * Timed tryLock on a locked lock times out
407       */
408 <    public void testTryLock_Timeout() throws InterruptedException {
409 <        final PublicReentrantLock lock = new PublicReentrantLock();
408 >    public void testTryLock_Timeout()      { testTryLock_Timeout(false); }
409 >    public void testTryLock_Timeout_fair() { testTryLock_Timeout(true); }
410 >    public void testTryLock_Timeout(boolean fair) {
411 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
412 >        final long timeoutMillis = timeoutMillis();
413          lock.lock();
414          Thread t = newStartedThread(new CheckedRunnable() {
415              public void realRun() throws InterruptedException {
416                  long startTime = System.nanoTime();
371                long timeoutMillis = 10;
417                  assertFalse(lock.tryLock(timeoutMillis, MILLISECONDS));
418                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
419              }});
# Line 380 | Line 425 | public class ReentrantLockTest extends J
425      /**
426       * getHoldCount returns number of recursive holds
427       */
428 <    public void testGetHoldCount() {
429 <        ReentrantLock lock = new ReentrantLock();
428 >    public void testGetHoldCount()      { testGetHoldCount(false); }
429 >    public void testGetHoldCount_fair() { testGetHoldCount(true); }
430 >    public void testGetHoldCount(boolean fair) {
431 >        final ReentrantLock lock = new ReentrantLock(fair);
432          for (int i = 1; i <= SIZE; i++) {
433              lock.lock();
434              assertEquals(i, lock.getHoldCount());
435          }
436          for (int i = SIZE; i > 0; i--) {
437              lock.unlock();
438 <            assertEquals(i-1, lock.getHoldCount());
438 >            assertEquals(i - 1, lock.getHoldCount());
439          }
440      }
441  
442      /**
443       * isLocked is true when locked and false when not
444       */
445 <    public void testIsLocked() throws Exception {
446 <        final ReentrantLock lock = new ReentrantLock();
447 <        assertFalse(lock.isLocked());
448 <        lock.lock();
449 <        assertTrue(lock.isLocked());
450 <        lock.lock();
451 <        assertTrue(lock.isLocked());
452 <        lock.unlock();
453 <        assertTrue(lock.isLocked());
454 <        lock.unlock();
455 <        assertFalse(lock.isLocked());
456 <        final CyclicBarrier barrier = new CyclicBarrier(2);
457 <        Thread t = newStartedThread(new CheckedRunnable() {
458 <            public void realRun() throws Exception {
459 <                lock.lock();
460 <                assertTrue(lock.isLocked());
461 <                barrier.await();
462 <                barrier.await();
463 <                lock.unlock();
464 <            }});
465 <
466 <        barrier.await();
467 <        assertTrue(lock.isLocked());
468 <        barrier.await();
469 <        awaitTermination(t);
470 <        assertFalse(lock.isLocked());
471 <    }
472 <
473 <    /**
474 <     * lockInterruptibly is interruptible.
428 <     */
429 <    public void testLockInterruptibly_Interrupted() throws InterruptedException {
430 <        final PublicReentrantLock lock = new PublicReentrantLock();
431 <        lock.lock();
432 <        Thread t = newStartedThread(new InterruptedLockRunnable(lock));
433 <        waitForQueuedThread(lock, t);
434 <        t.interrupt();
435 <        awaitTermination(t);
436 <        releaseLock(lock);
445 >    public void testIsLocked()      { testIsLocked(false); }
446 >    public void testIsLocked_fair() { testIsLocked(true); }
447 >    public void testIsLocked(boolean fair) {
448 >        final ReentrantLock lock = new ReentrantLock(fair);
449 >        try {
450 >            assertFalse(lock.isLocked());
451 >            lock.lock();
452 >            assertTrue(lock.isLocked());
453 >            lock.lock();
454 >            assertTrue(lock.isLocked());
455 >            lock.unlock();
456 >            assertTrue(lock.isLocked());
457 >            lock.unlock();
458 >            assertFalse(lock.isLocked());
459 >            final CyclicBarrier barrier = new CyclicBarrier(2);
460 >            Thread t = newStartedThread(new CheckedRunnable() {
461 >                    public void realRun() throws Exception {
462 >                        lock.lock();
463 >                        assertTrue(lock.isLocked());
464 >                        barrier.await();
465 >                        barrier.await();
466 >                        lock.unlock();
467 >                    }});
468 >
469 >            barrier.await();
470 >            assertTrue(lock.isLocked());
471 >            barrier.await();
472 >            awaitTermination(t);
473 >            assertFalse(lock.isLocked());
474 >        } catch (Exception fail) { threadUnexpectedException(fail); }
475      }
476  
477      /**
478       * lockInterruptibly succeeds when unlocked, else is interruptible
479       */
480 <    public void testLockInterruptibly_Interrupted2() throws InterruptedException {
481 <        final PublicReentrantLock lock = new PublicReentrantLock();
482 <        lock.lockInterruptibly();
480 >    public void testLockInterruptibly()      { testLockInterruptibly(false); }
481 >    public void testLockInterruptibly_fair() { testLockInterruptibly(true); }
482 >    public void testLockInterruptibly(boolean fair) {
483 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
484 >        try {
485 >            lock.lockInterruptibly();
486 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
487 >        assertLockedByMoi(lock);
488          Thread t = newStartedThread(new InterruptedLockRunnable(lock));
489          waitForQueuedThread(lock, t);
490          t.interrupt();
# Line 454 | Line 497 | public class ReentrantLockTest extends J
497      /**
498       * Calling await without holding lock throws IllegalMonitorStateException
499       */
500 <    public void testAwait_IllegalMonitor() throws InterruptedException {
501 <        final ReentrantLock lock = new ReentrantLock();
502 <        final Condition c = lock.newCondition();
503 <        try {
504 <            c.await();
505 <            shouldThrow();
506 <        } catch (IllegalMonitorStateException success) {}
507 <        try {
508 <            c.await(LONG_DELAY_MS, MILLISECONDS);
509 <            shouldThrow();
510 <        } catch (IllegalMonitorStateException success) {}
511 <        try {
512 <            c.awaitNanos(100);
513 <            shouldThrow();
471 <        } catch (IllegalMonitorStateException success) {}
472 <        try {
473 <            c.awaitUninterruptibly();
474 <            shouldThrow();
475 <        } catch (IllegalMonitorStateException success) {}
500 >    public void testAwait_IMSE()      { testAwait_IMSE(false); }
501 >    public void testAwait_IMSE_fair() { testAwait_IMSE(true); }
502 >    public void testAwait_IMSE(boolean fair) {
503 >        final ReentrantLock lock = new ReentrantLock(fair);
504 >        final Condition c = lock.newCondition();
505 >        for (AwaitMethod awaitMethod : AwaitMethod.values()) {
506 >            long startTime = System.nanoTime();
507 >            try {
508 >                await(c, awaitMethod);
509 >                shouldThrow();
510 >            } catch (IllegalMonitorStateException success) {
511 >            } catch (InterruptedException e) { threadUnexpectedException(e); }
512 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
513 >        }
514      }
515  
516      /**
517       * Calling signal without holding lock throws IllegalMonitorStateException
518       */
519 <    public void testSignal_IllegalMonitor() {
520 <        final ReentrantLock lock = new ReentrantLock();
519 >    public void testSignal_IMSE()      { testSignal_IMSE(false); }
520 >    public void testSignal_IMSE_fair() { testSignal_IMSE(true); }
521 >    public void testSignal_IMSE(boolean fair) {
522 >        final ReentrantLock lock = new ReentrantLock(fair);
523          final Condition c = lock.newCondition();
524          try {
525              c.signal();
# Line 490 | Line 530 | public class ReentrantLockTest extends J
530      /**
531       * awaitNanos without a signal times out
532       */
533 <    public void testAwaitNanos_Timeout() throws InterruptedException {
534 <        final ReentrantLock lock = new ReentrantLock();
533 >    public void testAwaitNanos_Timeout()      { testAwaitNanos_Timeout(false); }
534 >    public void testAwaitNanos_Timeout_fair() { testAwaitNanos_Timeout(true); }
535 >    public void testAwaitNanos_Timeout(boolean fair) {
536 >        final ReentrantLock lock = new ReentrantLock(fair);
537          final Condition c = lock.newCondition();
538 +        final long timeoutMillis = timeoutMillis();
539 +        final long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
540          lock.lock();
541 <        long startTime = System.nanoTime();
542 <        long timeoutMillis = 10;
543 <        long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
544 <        long nanosRemaining = c.awaitNanos(timeoutNanos);
545 <        assertTrue(nanosRemaining <= 0);
541 >        final long startTime = System.nanoTime();
542 >        try {
543 >            long nanosRemaining = c.awaitNanos(timeoutNanos);
544 >            assertTrue(nanosRemaining <= 0);
545 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
546          assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
547          lock.unlock();
548      }
# Line 506 | Line 550 | public class ReentrantLockTest extends J
550      /**
551       * timed await without a signal times out
552       */
553 <    public void testAwait_Timeout() throws InterruptedException {
554 <        final ReentrantLock lock = new ReentrantLock();
553 >    public void testAwait_Timeout()      { testAwait_Timeout(false); }
554 >    public void testAwait_Timeout_fair() { testAwait_Timeout(true); }
555 >    public void testAwait_Timeout(boolean fair) {
556 >        final ReentrantLock lock = new ReentrantLock(fair);
557          final Condition c = lock.newCondition();
558 +        final long timeoutMillis = timeoutMillis();
559          lock.lock();
560 <        long startTime = System.nanoTime();
561 <        long timeoutMillis = 10;
562 <        assertFalse(c.await(timeoutMillis, MILLISECONDS));
560 >        final long startTime = System.nanoTime();
561 >        try {
562 >            assertFalse(c.await(timeoutMillis, MILLISECONDS));
563 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
564          assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
565          lock.unlock();
566      }
# Line 520 | Line 568 | public class ReentrantLockTest extends J
568      /**
569       * awaitUntil without a signal times out
570       */
571 <    public void testAwaitUntil_Timeout() throws InterruptedException {
572 <        final ReentrantLock lock = new ReentrantLock();
571 >    public void testAwaitUntil_Timeout()      { testAwaitUntil_Timeout(false); }
572 >    public void testAwaitUntil_Timeout_fair() { testAwaitUntil_Timeout(true); }
573 >    public void testAwaitUntil_Timeout(boolean fair) {
574 >        final ReentrantLock lock = new ReentrantLock(fair);
575          final Condition c = lock.newCondition();
576          lock.lock();
577 <        long startTime = System.nanoTime();
578 <        long timeoutMillis = 10;
579 <        java.util.Date d = new java.util.Date();
580 <        assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + timeoutMillis)));
581 <        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
577 >        // We shouldn't assume that nanoTime and currentTimeMillis
578 >        // use the same time source, so don't use nanoTime here.
579 >        final java.util.Date delayedDate = delayedDate(timeoutMillis());
580 >        try {
581 >            assertFalse(c.awaitUntil(delayedDate));
582 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
583 >        assertTrue(new java.util.Date().getTime() >= delayedDate.getTime());
584          lock.unlock();
585      }
586  
587      /**
588       * await returns when signalled
589       */
590 <    public void testAwait() throws InterruptedException {
591 <        final PublicReentrantLock lock = new PublicReentrantLock();
590 >    public void testAwait()      { testAwait(false); }
591 >    public void testAwait_fair() { testAwait(true); }
592 >    public void testAwait(boolean fair) {
593 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
594          final Condition c = lock.newCondition();
595          final CountDownLatch locked = new CountDownLatch(1);
596          Thread t = newStartedThread(new CheckedRunnable() {
# Line 547 | Line 601 | public class ReentrantLockTest extends J
601                  lock.unlock();
602              }});
603  
604 <        locked.await();
604 >        await(locked);
605          lock.lock();
606          assertHasWaiters(lock, c, t);
607          c.signal();
# Line 560 | Line 614 | public class ReentrantLockTest extends J
614      /**
615       * hasWaiters throws NPE if null
616       */
617 <    public void testHasWaitersNPE() {
618 <        final ReentrantLock lock = new ReentrantLock();
617 >    public void testHasWaitersNPE()      { testHasWaitersNPE(false); }
618 >    public void testHasWaitersNPE_fair() { testHasWaitersNPE(true); }
619 >    public void testHasWaitersNPE(boolean fair) {
620 >        final ReentrantLock lock = new ReentrantLock(fair);
621          try {
622              lock.hasWaiters(null);
623              shouldThrow();
# Line 571 | Line 627 | public class ReentrantLockTest extends J
627      /**
628       * getWaitQueueLength throws NPE if null
629       */
630 <    public void testGetWaitQueueLengthNPE() {
631 <        final ReentrantLock lock = new ReentrantLock();
630 >    public void testGetWaitQueueLengthNPE()      { testGetWaitQueueLengthNPE(false); }
631 >    public void testGetWaitQueueLengthNPE_fair() { testGetWaitQueueLengthNPE(true); }
632 >    public void testGetWaitQueueLengthNPE(boolean fair) {
633 >        final ReentrantLock lock = new ReentrantLock(fair);
634          try {
635              lock.getWaitQueueLength(null);
636              shouldThrow();
# Line 582 | Line 640 | public class ReentrantLockTest extends J
640      /**
641       * getWaitingThreads throws NPE if null
642       */
643 <    public void testGetWaitingThreadsNPE() {
644 <        final PublicReentrantLock lock = new PublicReentrantLock();
643 >    public void testGetWaitingThreadsNPE()      { testGetWaitingThreadsNPE(false); }
644 >    public void testGetWaitingThreadsNPE_fair() { testGetWaitingThreadsNPE(true); }
645 >    public void testGetWaitingThreadsNPE(boolean fair) {
646 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
647          try {
648              lock.getWaitingThreads(null);
649              shouldThrow();
# Line 593 | Line 653 | public class ReentrantLockTest extends J
653      /**
654       * hasWaiters throws IllegalArgumentException if not owned
655       */
656 <    public void testHasWaitersIAE() {
657 <        final ReentrantLock lock = new ReentrantLock();
656 >    public void testHasWaitersIAE()      { testHasWaitersIAE(false); }
657 >    public void testHasWaitersIAE_fair() { testHasWaitersIAE(true); }
658 >    public void testHasWaitersIAE(boolean fair) {
659 >        final ReentrantLock lock = new ReentrantLock(fair);
660          final Condition c = lock.newCondition();
661 <        final ReentrantLock lock2 = new ReentrantLock();
661 >        final ReentrantLock lock2 = new ReentrantLock(fair);
662          try {
663              lock2.hasWaiters(c);
664              shouldThrow();
# Line 606 | Line 668 | public class ReentrantLockTest extends J
668      /**
669       * hasWaiters throws IllegalMonitorStateException if not locked
670       */
671 <    public void testHasWaitersIMSE() {
672 <        final ReentrantLock lock = new ReentrantLock();
671 >    public void testHasWaitersIMSE()      { testHasWaitersIMSE(false); }
672 >    public void testHasWaitersIMSE_fair() { testHasWaitersIMSE(true); }
673 >    public void testHasWaitersIMSE(boolean fair) {
674 >        final ReentrantLock lock = new ReentrantLock(fair);
675          final Condition c = lock.newCondition();
676          try {
677              lock.hasWaiters(c);
# Line 618 | Line 682 | public class ReentrantLockTest extends J
682      /**
683       * getWaitQueueLength throws IllegalArgumentException if not owned
684       */
685 <    public void testGetWaitQueueLengthIAE() {
686 <        final ReentrantLock lock = new ReentrantLock();
685 >    public void testGetWaitQueueLengthIAE()      { testGetWaitQueueLengthIAE(false); }
686 >    public void testGetWaitQueueLengthIAE_fair() { testGetWaitQueueLengthIAE(true); }
687 >    public void testGetWaitQueueLengthIAE(boolean fair) {
688 >        final ReentrantLock lock = new ReentrantLock(fair);
689          final Condition c = lock.newCondition();
690 <        final ReentrantLock lock2 = new ReentrantLock();
690 >        final ReentrantLock lock2 = new ReentrantLock(fair);
691          try {
692              lock2.getWaitQueueLength(c);
693              shouldThrow();
# Line 631 | Line 697 | public class ReentrantLockTest extends J
697      /**
698       * getWaitQueueLength throws IllegalMonitorStateException if not locked
699       */
700 <    public void testGetWaitQueueLengthIMSE() {
701 <        final ReentrantLock lock = new ReentrantLock();
700 >    public void testGetWaitQueueLengthIMSE()      { testGetWaitQueueLengthIMSE(false); }
701 >    public void testGetWaitQueueLengthIMSE_fair() { testGetWaitQueueLengthIMSE(true); }
702 >    public void testGetWaitQueueLengthIMSE(boolean fair) {
703 >        final ReentrantLock lock = new ReentrantLock(fair);
704          final Condition c = lock.newCondition();
705          try {
706              lock.getWaitQueueLength(c);
# Line 643 | Line 711 | public class ReentrantLockTest extends J
711      /**
712       * getWaitingThreads throws IllegalArgumentException if not owned
713       */
714 <    public void testGetWaitingThreadsIAE() {
715 <        final PublicReentrantLock lock = new PublicReentrantLock();
714 >    public void testGetWaitingThreadsIAE()      { testGetWaitingThreadsIAE(false); }
715 >    public void testGetWaitingThreadsIAE_fair() { testGetWaitingThreadsIAE(true); }
716 >    public void testGetWaitingThreadsIAE(boolean fair) {
717 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
718          final Condition c = lock.newCondition();
719 <        final PublicReentrantLock lock2 = new PublicReentrantLock();
719 >        final PublicReentrantLock lock2 = new PublicReentrantLock(fair);
720          try {
721              lock2.getWaitingThreads(c);
722              shouldThrow();
# Line 656 | Line 726 | public class ReentrantLockTest extends J
726      /**
727       * getWaitingThreads throws IllegalMonitorStateException if not locked
728       */
729 <    public void testGetWaitingThreadsIMSE() {
730 <        final PublicReentrantLock lock = new PublicReentrantLock();
729 >    public void testGetWaitingThreadsIMSE()      { testGetWaitingThreadsIMSE(false); }
730 >    public void testGetWaitingThreadsIMSE_fair() { testGetWaitingThreadsIMSE(true); }
731 >    public void testGetWaitingThreadsIMSE(boolean fair) {
732 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
733          final Condition c = lock.newCondition();
734          try {
735              lock.getWaitingThreads(c);
# Line 668 | Line 740 | public class ReentrantLockTest extends J
740      /**
741       * hasWaiters returns true when a thread is waiting, else false
742       */
743 <    public void testHasWaiters() throws InterruptedException {
744 <        final PublicReentrantLock lock = new PublicReentrantLock();
743 >    public void testHasWaiters()      { testHasWaiters(false); }
744 >    public void testHasWaiters_fair() { testHasWaiters(true); }
745 >    public void testHasWaiters(boolean fair) {
746 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
747          final Condition c = lock.newCondition();
748 <        final CountDownLatch locked = new CountDownLatch(1);
748 >        final CountDownLatch pleaseSignal = new CountDownLatch(1);
749          Thread t = newStartedThread(new CheckedRunnable() {
750              public void realRun() throws InterruptedException {
751                  lock.lock();
752                  assertHasNoWaiters(lock, c);
753                  assertFalse(lock.hasWaiters(c));
754 <                locked.countDown();
754 >                pleaseSignal.countDown();
755                  c.await();
756                  assertHasNoWaiters(lock, c);
757                  assertFalse(lock.hasWaiters(c));
758                  lock.unlock();
759              }});
760  
761 <        locked.await();
761 >        await(pleaseSignal);
762          lock.lock();
763          assertHasWaiters(lock, c, t);
764          assertTrue(lock.hasWaiters(c));
# Line 699 | Line 773 | public class ReentrantLockTest extends J
773      /**
774       * getWaitQueueLength returns number of waiting threads
775       */
776 <    public void testGetWaitQueueLength() throws InterruptedException {
777 <        final PublicReentrantLock lock = new PublicReentrantLock();
776 >    public void testGetWaitQueueLength()      { testGetWaitQueueLength(false); }
777 >    public void testGetWaitQueueLength_fair() { testGetWaitQueueLength(true); }
778 >    public void testGetWaitQueueLength(boolean fair) {
779 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
780          final Condition c = lock.newCondition();
781          final CountDownLatch locked1 = new CountDownLatch(1);
782          final CountDownLatch locked2 = new CountDownLatch(1);
# Line 729 | Line 805 | public class ReentrantLockTest extends J
805          lock.unlock();
806  
807          t1.start();
808 <        locked1.await();
808 >        await(locked1);
809  
810          lock.lock();
811          assertHasWaiters(lock, c, t1);
# Line 737 | Line 813 | public class ReentrantLockTest extends J
813          lock.unlock();
814  
815          t2.start();
816 <        locked2.await();
816 >        await(locked2);
817  
818          lock.lock();
819          assertHasWaiters(lock, c, t1, t2);
# Line 755 | Line 831 | public class ReentrantLockTest extends J
831      /**
832       * getWaitingThreads returns only and all waiting threads
833       */
834 <    public void testGetWaitingThreads() throws InterruptedException {
835 <        final PublicReentrantLock lock = new PublicReentrantLock();
834 >    public void testGetWaitingThreads()      { testGetWaitingThreads(false); }
835 >    public void testGetWaitingThreads_fair() { testGetWaitingThreads(true); }
836 >    public void testGetWaitingThreads(boolean fair) {
837 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
838          final Condition c = lock.newCondition();
839          final CountDownLatch locked1 = new CountDownLatch(1);
840          final CountDownLatch locked2 = new CountDownLatch(1);
# Line 783 | Line 861 | public class ReentrantLockTest extends J
861          lock.unlock();
862  
863          t1.start();
864 <        locked1.await();
864 >        await(locked1);
865  
866          lock.lock();
867          assertHasWaiters(lock, c, t1);
# Line 793 | Line 871 | public class ReentrantLockTest extends J
871          lock.unlock();
872  
873          t2.start();
874 <        locked2.await();
874 >        await(locked2);
875  
876          lock.lock();
877          assertHasWaiters(lock, c, t1, t2);
# Line 811 | Line 889 | public class ReentrantLockTest extends J
889      }
890  
891      /**
892 <     * awaitUninterruptibly doesn't abort on interrupt
892 >     * awaitUninterruptibly is uninterruptible
893       */
894 <    public void testAwaitUninterruptibly() throws InterruptedException {
895 <        final ReentrantLock lock = new ReentrantLock();
896 <        final Condition c = lock.newCondition();
897 <        final CountDownLatch locked = new CountDownLatch(1);
898 <        Thread t = newStartedThread(new CheckedRunnable() {
894 >    public void testAwaitUninterruptibly()      { testAwaitUninterruptibly(false); }
895 >    public void testAwaitUninterruptibly_fair() { testAwaitUninterruptibly(true); }
896 >    public void testAwaitUninterruptibly(boolean fair) {
897 >        final ReentrantLock lock = new ReentrantLock(fair);
898 >        final Condition condition = lock.newCondition();
899 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
900 >
901 >        Thread t1 = newStartedThread(new CheckedRunnable() {
902              public void realRun() {
903 +                // Interrupt before awaitUninterruptibly
904                  lock.lock();
905 <                locked.countDown();
906 <                c.awaitUninterruptibly();
905 >                pleaseInterrupt.countDown();
906 >                Thread.currentThread().interrupt();
907 >                condition.awaitUninterruptibly();
908 >                assertTrue(Thread.interrupted());
909 >                lock.unlock();
910 >            }});
911 >
912 >        Thread t2 = newStartedThread(new CheckedRunnable() {
913 >            public void realRun() {
914 >                // Interrupt during awaitUninterruptibly
915 >                lock.lock();
916 >                pleaseInterrupt.countDown();
917 >                condition.awaitUninterruptibly();
918                  assertTrue(Thread.interrupted());
919                  lock.unlock();
920              }});
921  
922 <        locked.await();
922 >        await(pleaseInterrupt);
923 >        t2.interrupt();
924          lock.lock();
925          lock.unlock();
926 <        t.interrupt();
927 <        long timeoutMillis = 10;
928 <        assertThreadJoinTimesOut(t, timeoutMillis);
926 >        assertThreadBlocks(t1, Thread.State.WAITING);
927 >        assertThreadBlocks(t2, Thread.State.WAITING);
928 >
929          lock.lock();
930 <        c.signal();
930 >        condition.signalAll();
931          lock.unlock();
838        awaitTermination(t);
839    }
932  
933 <    /**
934 <     * await is interruptible
843 <     */
844 <    public void testAwait_Interrupt() throws InterruptedException {
845 <        final PublicReentrantLock lock = new PublicReentrantLock();
846 <        final Condition c = lock.newCondition();
847 <        final CountDownLatch locked = new CountDownLatch(1);
848 <        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
849 <            public void realRun() throws InterruptedException {
850 <                lock.lock();
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 <        locked.await();
867 <        assertHasWaiters(lock, c, t);
868 <        t.interrupt();
869 <        awaitTermination(t);
870 <        assertFalse(lock.isLocked());
933 >        awaitTermination(t1);
934 >        awaitTermination(t2);
935      }
936  
937      /**
938 <     * awaitNanos is interruptible
938 >     * await/awaitNanos/awaitUntil is interruptible
939       */
940 <    public void testAwaitNanos_Interrupt() throws InterruptedException {
941 <        final PublicReentrantLock lock = new PublicReentrantLock();
940 >    public void testInterruptible_await()           { testInterruptible(false, AwaitMethod.await); }
941 >    public void testInterruptible_await_fair()      { testInterruptible(true,  AwaitMethod.await); }
942 >    public void testInterruptible_awaitTimed()      { testInterruptible(false, AwaitMethod.awaitTimed); }
943 >    public void testInterruptible_awaitTimed_fair() { testInterruptible(true,  AwaitMethod.awaitTimed); }
944 >    public void testInterruptible_awaitNanos()      { testInterruptible(false, AwaitMethod.awaitNanos); }
945 >    public void testInterruptible_awaitNanos_fair() { testInterruptible(true,  AwaitMethod.awaitNanos); }
946 >    public void testInterruptible_awaitUntil()      { testInterruptible(false, AwaitMethod.awaitUntil); }
947 >    public void testInterruptible_awaitUntil_fair() { testInterruptible(true,  AwaitMethod.awaitUntil); }
948 >    public void testInterruptible(boolean fair, final AwaitMethod awaitMethod) {
949 >        final PublicReentrantLock lock =
950 >            new PublicReentrantLock(fair);
951          final Condition c = lock.newCondition();
952 <        final CountDownLatch locked = new CountDownLatch(1);
952 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
953          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
954              public void realRun() throws InterruptedException {
955                  lock.lock();
956 <                assertTrue(lock.isLocked());
884 <                assertTrue(lock.isHeldByCurrentThread());
956 >                assertLockedByMoi(lock);
957                  assertHasNoWaiters(lock, c);
958 <                locked.countDown();
958 >                pleaseInterrupt.countDown();
959                  try {
960 <                    c.awaitNanos(MILLISECONDS.toNanos(2 * LONG_DELAY_MS));
960 >                    await(c, awaitMethod);
961                  } finally {
962 <                    assertTrue(lock.isLocked());
891 <                    assertTrue(lock.isHeldByCurrentThread());
962 >                    assertLockedByMoi(lock);
963                      assertHasNoWaiters(lock, c);
964                      lock.unlock();
965                      assertFalse(Thread.interrupted());
966                  }
967              }});
968  
969 <        locked.await();
969 >        await(pleaseInterrupt);
970          assertHasWaiters(lock, c, t);
971          t.interrupt();
972          awaitTermination(t);
973 <        assertFalse(lock.isLocked());
973 >        assertNotLocked(lock);
974      }
975  
976      /**
977 <     * awaitUntil is interruptible
977 >     * signalAll wakes up all threads
978       */
979 <    public void testAwaitUntil_Interrupt() throws InterruptedException {
980 <        final PublicReentrantLock lock = new PublicReentrantLock();
979 >    public void testSignalAll_await()           { testSignalAll(false, AwaitMethod.await); }
980 >    public void testSignalAll_await_fair()      { testSignalAll(true,  AwaitMethod.await); }
981 >    public void testSignalAll_awaitTimed()      { testSignalAll(false, AwaitMethod.awaitTimed); }
982 >    public void testSignalAll_awaitTimed_fair() { testSignalAll(true,  AwaitMethod.awaitTimed); }
983 >    public void testSignalAll_awaitNanos()      { testSignalAll(false, AwaitMethod.awaitNanos); }
984 >    public void testSignalAll_awaitNanos_fair() { testSignalAll(true,  AwaitMethod.awaitNanos); }
985 >    public void testSignalAll_awaitUntil()      { testSignalAll(false, AwaitMethod.awaitUntil); }
986 >    public void testSignalAll_awaitUntil_fair() { testSignalAll(true,  AwaitMethod.awaitUntil); }
987 >    public void testSignalAll(boolean fair, final AwaitMethod awaitMethod) {
988 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
989          final Condition c = lock.newCondition();
990 <        final CountDownLatch locked = new CountDownLatch(1);
991 <        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
990 >        final CountDownLatch pleaseSignal = new CountDownLatch(2);
991 >        class Awaiter extends CheckedRunnable {
992              public void realRun() throws InterruptedException {
993                  lock.lock();
994 <                assertTrue(lock.isLocked());
995 <                assertTrue(lock.isHeldByCurrentThread());
996 <                assertHasNoWaiters(lock, c);
997 <                locked.countDown();
998 <                java.util.Date d = new java.util.Date();
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 <            }});
994 >                pleaseSignal.countDown();
995 >                await(c, awaitMethod);
996 >                lock.unlock();
997 >            }
998 >        }
999  
1000 <        locked.await();
1001 <        assertHasWaiters(lock, c, t);
1002 <        t.interrupt();
1003 <        awaitTermination(t);
1004 <        assertFalse(lock.isLocked());
1000 >        Thread t1 = newStartedThread(new Awaiter());
1001 >        Thread t2 = newStartedThread(new Awaiter());
1002 >
1003 >        await(pleaseSignal);
1004 >        lock.lock();
1005 >        assertHasWaiters(lock, c, t1, t2);
1006 >        c.signalAll();
1007 >        assertHasNoWaiters(lock, c);
1008 >        lock.unlock();
1009 >        awaitTermination(t1);
1010 >        awaitTermination(t2);
1011      }
1012  
1013      /**
1014 <     * signalAll wakes up all threads
1014 >     * signal wakes up waiting threads in FIFO order
1015       */
1016 <    public void testSignalAll() throws InterruptedException {
1017 <        final PublicReentrantLock lock = new PublicReentrantLock();
1016 >    public void testSignalWakesFifo()      { testSignalWakesFifo(false); }
1017 >    public void testSignalWakesFifo_fair() { testSignalWakesFifo(true); }
1018 >    public void testSignalWakesFifo(boolean fair) {
1019 >        final PublicReentrantLock lock =
1020 >            new PublicReentrantLock(fair);
1021          final Condition c = lock.newCondition();
1022 <        final CountDownLatch locked = new CountDownLatch(2);
1022 >        final CountDownLatch locked1 = new CountDownLatch(1);
1023 >        final CountDownLatch locked2 = new CountDownLatch(1);
1024          Thread t1 = newStartedThread(new CheckedRunnable() {
1025              public void realRun() throws InterruptedException {
1026                  lock.lock();
1027 <                locked.countDown();
1027 >                locked1.countDown();
1028                  c.await();
1029                  lock.unlock();
1030              }});
1031  
1032 +        await(locked1);
1033 +
1034          Thread t2 = newStartedThread(new CheckedRunnable() {
1035              public void realRun() throws InterruptedException {
1036                  lock.lock();
1037 <                locked.countDown();
1037 >                locked2.countDown();
1038                  c.await();
1039                  lock.unlock();
1040              }});
1041  
1042 <        locked.await();
1042 >        await(locked2);
1043 >
1044          lock.lock();
1045          assertHasWaiters(lock, c, t1, t2);
1046 <        c.signalAll();
1046 >        assertFalse(lock.hasQueuedThreads());
1047 >        c.signal();
1048 >        assertHasWaiters(lock, c, t2);
1049 >        assertTrue(lock.hasQueuedThread(t1));
1050 >        assertFalse(lock.hasQueuedThread(t2));
1051 >        c.signal();
1052          assertHasNoWaiters(lock, c);
1053 +        assertTrue(lock.hasQueuedThread(t1));
1054 +        assertTrue(lock.hasQueuedThread(t2));
1055          lock.unlock();
1056          awaitTermination(t1);
1057          awaitTermination(t2);
# Line 971 | Line 1060 | public class ReentrantLockTest extends J
1060      /**
1061       * await after multiple reentrant locking preserves lock count
1062       */
1063 <    public void testAwaitLockCount() throws InterruptedException {
1064 <        final PublicReentrantLock lock = new PublicReentrantLock();
1063 >    public void testAwaitLockCount()      { testAwaitLockCount(false); }
1064 >    public void testAwaitLockCount_fair() { testAwaitLockCount(true); }
1065 >    public void testAwaitLockCount(boolean fair) {
1066 >        final PublicReentrantLock lock = new PublicReentrantLock(fair);
1067          final Condition c = lock.newCondition();
1068 <        final CountDownLatch locked = new CountDownLatch(2);
1068 >        final CountDownLatch pleaseSignal = new CountDownLatch(2);
1069          Thread t1 = newStartedThread(new CheckedRunnable() {
1070              public void realRun() throws InterruptedException {
1071                  lock.lock();
1072 <                assertLockedBy(lock, Thread.currentThread());
1072 >                assertLockedByMoi(lock);
1073                  assertEquals(1, lock.getHoldCount());
1074 <                locked.countDown();
1074 >                pleaseSignal.countDown();
1075                  c.await();
1076 <                assertLockedBy(lock, Thread.currentThread());
1076 >                assertLockedByMoi(lock);
1077                  assertEquals(1, lock.getHoldCount());
1078                  lock.unlock();
1079              }});
# Line 991 | Line 1082 | public class ReentrantLockTest extends J
1082              public void realRun() throws InterruptedException {
1083                  lock.lock();
1084                  lock.lock();
1085 <                assertLockedBy(lock, Thread.currentThread());
1085 >                assertLockedByMoi(lock);
1086                  assertEquals(2, lock.getHoldCount());
1087 <                locked.countDown();
1087 >                pleaseSignal.countDown();
1088                  c.await();
1089 <                assertLockedBy(lock, Thread.currentThread());
1089 >                assertLockedByMoi(lock);
1090                  assertEquals(2, lock.getHoldCount());
1091                  lock.unlock();
1092                  lock.unlock();
1093              }});
1094  
1095 <        locked.await();
1095 >        await(pleaseSignal);
1096          lock.lock();
1097          assertHasWaiters(lock, c, t1, t2);
1098          assertEquals(1, lock.getHoldCount());
# Line 1015 | Line 1106 | public class ReentrantLockTest extends J
1106      /**
1107       * A serialized lock deserializes as unlocked
1108       */
1109 <    public void testSerialization() throws Exception {
1110 <        ReentrantLock l = new ReentrantLock();
1111 <        l.lock();
1112 <        l.unlock();
1113 <
1114 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
1115 <        ObjectOutputStream out =
1116 <            new ObjectOutputStream(new BufferedOutputStream(bout));
1117 <        out.writeObject(l);
1118 <        out.close();
1119 <
1120 <        ByteArrayInputStream bin =
1121 <            new ByteArrayInputStream(bout.toByteArray());
1122 <        ObjectInputStream in =
1123 <            new ObjectInputStream(new BufferedInputStream(bin));
1124 <        ReentrantLock r = (ReentrantLock) in.readObject();
1125 <        r.lock();
1126 <        r.unlock();
1109 >    public void testSerialization()      { testSerialization(false); }
1110 >    public void testSerialization_fair() { testSerialization(true); }
1111 >    public void testSerialization(boolean fair) {
1112 >        final ReentrantLock lock = new ReentrantLock(fair);
1113 >        lock.lock();
1114 >
1115 >        ReentrantLock clone = serialClone(lock);
1116 >        assertEquals(lock.isFair(), clone.isFair());
1117 >        assertTrue(lock.isLocked());
1118 >        assertFalse(clone.isLocked());
1119 >        assertEquals(1, lock.getHoldCount());
1120 >        assertEquals(0, clone.getHoldCount());
1121 >        clone.lock();
1122 >        clone.lock();
1123 >        assertTrue(clone.isLocked());
1124 >        assertEquals(2, clone.getHoldCount());
1125 >        assertEquals(1, lock.getHoldCount());
1126 >        clone.unlock();
1127 >        clone.unlock();
1128 >        assertTrue(lock.isLocked());
1129 >        assertFalse(clone.isLocked());
1130      }
1131  
1132      /**
1133       * toString indicates current lock state
1134       */
1135 <    public void testToString() {
1136 <        ReentrantLock lock = new ReentrantLock();
1137 <        String us = lock.toString();
1138 <        assertTrue(us.indexOf("Unlocked") >= 0);
1135 >    public void testToString()      { testToString(false); }
1136 >    public void testToString_fair() { testToString(true); }
1137 >    public void testToString(boolean fair) {
1138 >        final ReentrantLock lock = new ReentrantLock(fair);
1139 >        assertTrue(lock.toString().contains("Unlocked"));
1140 >        lock.lock();
1141 >        assertTrue(lock.toString().contains("Locked by"));
1142 >        lock.unlock();
1143 >        assertTrue(lock.toString().contains("Unlocked"));
1144 >    }
1145 >
1146 >    /**
1147 >     * Tests scenario for JDK-8187408
1148 >     * AbstractQueuedSynchronizer wait queue corrupted when thread awaits without holding the lock
1149 >     */
1150 >    public void testBug8187408() throws InterruptedException {
1151 >        final ThreadLocalRandom rnd = ThreadLocalRandom.current();
1152 >        final AwaitMethod awaitMethod = randomAwaitMethod();
1153 >        final int nThreads = rnd.nextInt(2, 10);
1154 >        final ReentrantLock lock = new ReentrantLock();
1155 >        final Condition cond = lock.newCondition();
1156 >        final CountDownLatch done = new CountDownLatch(nThreads);
1157 >        final ArrayList<Thread> threads = new ArrayList<>();
1158 >
1159 >        Runnable rogue = () -> {
1160 >            while (done.getCount() > 0) {
1161 >                try {
1162 >                    // call await without holding lock?!
1163 >                    await(cond, awaitMethod);
1164 >                    throw new AssertionError("should throw");
1165 >                }
1166 >                catch (IllegalMonitorStateException success) {}
1167 >                catch (Throwable fail) { threadUnexpectedException(fail); }}};
1168 >        Thread rogueThread = new Thread(rogue, "rogue");
1169 >        threads.add(rogueThread);
1170 >        rogueThread.start();
1171 >
1172 >        Runnable waiter = () -> {
1173 >            lock.lock();
1174 >            try {
1175 >                done.countDown();
1176 >                cond.await();
1177 >            } catch (Throwable fail) {
1178 >                threadUnexpectedException(fail);
1179 >            } finally {
1180 >                lock.unlock();
1181 >            }};
1182 >        for (int i = 0; i < nThreads; i++) {
1183 >            Thread thread = new Thread(waiter, "waiter");
1184 >            threads.add(thread);
1185 >            thread.start();
1186 >        }
1187 >
1188 >        assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
1189 >        lock.lock();
1190 >        try {
1191 >            assertEquals(nThreads, lock.getWaitQueueLength(cond));
1192 >        } finally {
1193 >            cond.signalAll();
1194 >            lock.unlock();
1195 >        }
1196 >        for (Thread thread : threads) {
1197 >            thread.join(LONG_DELAY_MS);
1198 >            assertFalse(thread.isAlive());
1199 >        }
1200 >    }
1201 >
1202 >    /**
1203 >     * ThreadMXBean reports the blockers that we expect.
1204 >     */
1205 >    public void testBlockers() {
1206 >        if (!testImplementationDetails) return;
1207 >        final boolean fair = randomBoolean();
1208 >        final boolean timedAcquire = randomBoolean();
1209 >        final boolean timedAwait = randomBoolean();
1210 >        final String syncClassName = fair
1211 >            ? "ReentrantLock$FairSync"
1212 >            : "ReentrantLock$NonfairSync";
1213 >        final String conditionClassName
1214 >            = "AbstractQueuedSynchronizer$ConditionObject";
1215 >        final Thread.State expectedAcquireState = timedAcquire
1216 >            ? Thread.State.TIMED_WAITING
1217 >            : Thread.State.WAITING;
1218 >        final Thread.State expectedAwaitState = timedAwait
1219 >            ? Thread.State.TIMED_WAITING
1220 >            : Thread.State.WAITING;
1221 >        final Lock lock = new ReentrantLock(fair);
1222 >        final Condition condition = lock.newCondition();
1223 >        final AtomicBoolean conditionSatisfied = new AtomicBoolean(false);
1224 >        lock.lock();
1225 >        final Thread thread = newStartedThread((Action) () -> {
1226 >            if (timedAcquire)
1227 >                lock.tryLock(LONGER_DELAY_MS, MILLISECONDS);
1228 >            else
1229 >                lock.lock();
1230 >            while (!conditionSatisfied.get())
1231 >                if (timedAwait)
1232 >                    condition.await(LONGER_DELAY_MS, MILLISECONDS);
1233 >                else
1234 >                    condition.await();
1235 >        });
1236 >        Callable<Boolean> waitingForLock = () -> {
1237 >            String className;
1238 >            return thread.getState() == expectedAcquireState
1239 >            && (className = blockerClassName(thread)) != null
1240 >            && className.endsWith(syncClassName);
1241 >        };
1242 >        waitForThreadToEnterWaitState(thread, waitingForLock);
1243 >
1244 >        lock.unlock();
1245 >        Callable<Boolean> waitingForCondition = () -> {
1246 >            String className;
1247 >            return thread.getState() == expectedAwaitState
1248 >            && (className = blockerClassName(thread)) != null
1249 >            && className.endsWith(conditionClassName);
1250 >        };
1251 >        waitForThreadToEnterWaitState(thread, waitingForCondition);
1252 >
1253 >        // politely release the waiter
1254 >        conditionSatisfied.set(true);
1255          lock.lock();
1256 <        String ls = lock.toString();
1257 <        assertTrue(ls.indexOf("Locked") >= 0);
1256 >        try {
1257 >            condition.signal();
1258 >        } finally { lock.unlock(); }
1259 >
1260 >        awaitTermination(thread);
1261      }
1262   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines