/[cvs]/jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java
ViewVC logotype

Contents of /jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.64 - (show annotations)
Wed Jun 13 18:36:31 2018 UTC (14 months, 1 week ago) by jsr166
Branch: MAIN
Changes since 1.63: +4 -4 lines
rename nanosTimeout to timeoutNanos

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/publicdomain/zero/1.0/
5 * Other contributors include Andrew Wright, Jeffrey Hayes,
6 * Pat Fisher, Mike Judd.
7 */
8
9 import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 import static java.util.concurrent.TimeUnit.NANOSECONDS;
11
12 import java.util.ArrayList;
13 import java.util.Arrays;
14 import java.util.Collection;
15 import java.util.HashSet;
16 import java.util.concurrent.ThreadLocalRandom;
17 import java.util.concurrent.locks.AbstractQueuedSynchronizer;
18 import java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject;
19
20 import junit.framework.Test;
21 import junit.framework.TestSuite;
22
23 @SuppressWarnings("WaitNotInLoop") // we implement spurious-wakeup freedom
24 public class AbstractQueuedSynchronizerTest extends JSR166TestCase {
25 public static void main(String[] args) {
26 main(suite(), args);
27 }
28 public static Test suite() {
29 return new TestSuite(AbstractQueuedSynchronizerTest.class);
30 }
31
32 /**
33 * A simple mutex class, adapted from the class javadoc. Exclusive
34 * acquire tests exercise this as a sample user extension. Other
35 * methods/features of AbstractQueuedSynchronizer are tested via
36 * other test classes, including those for ReentrantLock,
37 * ReentrantReadWriteLock, and Semaphore.
38 *
39 * Unlike the javadoc sample, we don't track owner thread via
40 * AbstractOwnableSynchronizer methods.
41 */
42 static class Mutex extends AbstractQueuedSynchronizer {
43 /** An eccentric value for locked synchronizer state. */
44 static final int LOCKED = (1 << 31) | (1 << 15);
45
46 static final int UNLOCKED = 0;
47
48 /** Owner thread is untracked, so this is really just isLocked(). */
49 @Override public boolean isHeldExclusively() {
50 int state = getState();
51 assertTrue(state == UNLOCKED || state == LOCKED);
52 return state == LOCKED;
53 }
54
55 @Override protected boolean tryAcquire(int acquires) {
56 assertEquals(LOCKED, acquires);
57 return compareAndSetState(UNLOCKED, LOCKED);
58 }
59
60 @Override protected boolean tryRelease(int releases) {
61 if (getState() != LOCKED) throw new IllegalMonitorStateException();
62 assertEquals(LOCKED, releases);
63 setState(UNLOCKED);
64 return true;
65 }
66
67 public boolean tryAcquireNanos(long nanos) throws InterruptedException {
68 return tryAcquireNanos(LOCKED, nanos);
69 }
70
71 public boolean tryAcquire() {
72 return tryAcquire(LOCKED);
73 }
74
75 public boolean tryRelease() {
76 return tryRelease(LOCKED);
77 }
78
79 public void acquire() {
80 acquire(LOCKED);
81 }
82
83 public void acquireInterruptibly() throws InterruptedException {
84 acquireInterruptibly(LOCKED);
85 }
86
87 public void release() {
88 release(LOCKED);
89 }
90
91 /** Faux-Implements Lock.newCondition(). */
92 public ConditionObject newCondition() {
93 return new ConditionObject();
94 }
95 }
96
97 /**
98 * A minimal latch class, to test shared mode.
99 */
100 static class BooleanLatch extends AbstractQueuedSynchronizer {
101 public boolean isSignalled() { return getState() != 0; }
102
103 public int tryAcquireShared(int ignore) {
104 return isSignalled() ? 1 : -1;
105 }
106
107 public boolean tryReleaseShared(int ignore) {
108 setState(1);
109 return true;
110 }
111 }
112
113 /**
114 * A runnable calling acquireInterruptibly that does not expect to
115 * be interrupted.
116 */
117 class InterruptibleSyncRunnable extends CheckedRunnable {
118 final Mutex sync;
119 InterruptibleSyncRunnable(Mutex sync) { this.sync = sync; }
120 public void realRun() throws InterruptedException {
121 sync.acquireInterruptibly();
122 }
123 }
124
125 /**
126 * A runnable calling acquireInterruptibly that expects to be
127 * interrupted.
128 */
129 class InterruptedSyncRunnable extends CheckedInterruptedRunnable {
130 final Mutex sync;
131 InterruptedSyncRunnable(Mutex sync) { this.sync = sync; }
132 public void realRun() throws InterruptedException {
133 sync.acquireInterruptibly();
134 }
135 }
136
137 /** A constant to clarify calls to checking methods below. */
138 static final Thread[] NO_THREADS = new Thread[0];
139
140 /**
141 * Spin-waits until sync.isQueued(t) becomes true.
142 */
143 void waitForQueuedThread(AbstractQueuedSynchronizer sync, Thread t) {
144 long startTime = System.nanoTime();
145 while (!sync.isQueued(t)) {
146 if (millisElapsedSince(startTime) > LONG_DELAY_MS)
147 throw new AssertionError("timed out");
148 Thread.yield();
149 }
150 assertTrue(t.isAlive());
151 }
152
153 /**
154 * Checks that sync has exactly the given queued threads.
155 */
156 void assertHasQueuedThreads(AbstractQueuedSynchronizer sync,
157 Thread... expected) {
158 Collection<Thread> actual = sync.getQueuedThreads();
159 assertEquals(expected.length > 0, sync.hasQueuedThreads());
160 assertEquals(expected.length, sync.getQueueLength());
161 assertEquals(expected.length, actual.size());
162 assertEquals(expected.length == 0, actual.isEmpty());
163 assertEquals(new HashSet<Thread>(actual),
164 new HashSet<Thread>(Arrays.asList(expected)));
165 }
166
167 /**
168 * Checks that sync has exactly the given (exclusive) queued threads.
169 */
170 void assertHasExclusiveQueuedThreads(AbstractQueuedSynchronizer sync,
171 Thread... expected) {
172 assertHasQueuedThreads(sync, expected);
173 assertEquals(new HashSet<Thread>(sync.getExclusiveQueuedThreads()),
174 new HashSet<Thread>(sync.getQueuedThreads()));
175 assertEquals(0, sync.getSharedQueuedThreads().size());
176 assertTrue(sync.getSharedQueuedThreads().isEmpty());
177 }
178
179 /**
180 * Checks that sync has exactly the given (shared) queued threads.
181 */
182 void assertHasSharedQueuedThreads(AbstractQueuedSynchronizer sync,
183 Thread... expected) {
184 assertHasQueuedThreads(sync, expected);
185 assertEquals(new HashSet<Thread>(sync.getSharedQueuedThreads()),
186 new HashSet<Thread>(sync.getQueuedThreads()));
187 assertEquals(0, sync.getExclusiveQueuedThreads().size());
188 assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
189 }
190
191 /**
192 * Checks that condition c has exactly the given waiter threads,
193 * after acquiring mutex.
194 */
195 void assertHasWaitersUnlocked(Mutex sync, ConditionObject c,
196 Thread... threads) {
197 sync.acquire();
198 assertHasWaitersLocked(sync, c, threads);
199 sync.release();
200 }
201
202 /**
203 * Checks that condition c has exactly the given waiter threads.
204 */
205 void assertHasWaitersLocked(Mutex sync, ConditionObject c,
206 Thread... threads) {
207 assertEquals(threads.length > 0, sync.hasWaiters(c));
208 assertEquals(threads.length, sync.getWaitQueueLength(c));
209 assertEquals(threads.length == 0, sync.getWaitingThreads(c).isEmpty());
210 assertEquals(threads.length, sync.getWaitingThreads(c).size());
211 assertEquals(new HashSet<Thread>(sync.getWaitingThreads(c)),
212 new HashSet<Thread>(Arrays.asList(threads)));
213 }
214
215 enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
216
217 /**
218 * Awaits condition using the specified AwaitMethod.
219 */
220 void await(ConditionObject c, AwaitMethod awaitMethod)
221 throws InterruptedException {
222 long timeoutMillis = 2 * LONG_DELAY_MS;
223 switch (awaitMethod) {
224 case await:
225 c.await();
226 break;
227 case awaitTimed:
228 assertTrue(c.await(timeoutMillis, MILLISECONDS));
229 break;
230 case awaitNanos:
231 long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
232 long nanosRemaining = c.awaitNanos(timeoutNanos);
233 assertTrue(nanosRemaining > 0);
234 break;
235 case awaitUntil:
236 assertTrue(c.awaitUntil(delayedDate(timeoutMillis)));
237 break;
238 default:
239 throw new AssertionError();
240 }
241 }
242
243 /**
244 * Checks that awaiting the given condition times out (using the
245 * default timeout duration).
246 */
247 void assertAwaitTimesOut(ConditionObject c, AwaitMethod awaitMethod) {
248 final long timeoutMillis = timeoutMillis();
249 final long startTime;
250 try {
251 switch (awaitMethod) {
252 case awaitTimed:
253 startTime = System.nanoTime();
254 assertFalse(c.await(timeoutMillis, MILLISECONDS));
255 assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
256 break;
257 case awaitNanos:
258 startTime = System.nanoTime();
259 long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
260 long nanosRemaining = c.awaitNanos(timeoutNanos);
261 assertTrue(nanosRemaining <= 0);
262 assertTrue(nanosRemaining > -MILLISECONDS.toNanos(LONG_DELAY_MS));
263 assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
264 break;
265 case awaitUntil:
266 // We shouldn't assume that nanoTime and currentTimeMillis
267 // use the same time source, so don't use nanoTime here.
268 java.util.Date delayedDate = delayedDate(timeoutMillis);
269 assertFalse(c.awaitUntil(delayedDate(timeoutMillis)));
270 assertTrue(new java.util.Date().getTime() >= delayedDate.getTime());
271 break;
272 default:
273 throw new UnsupportedOperationException();
274 }
275 } catch (InterruptedException ie) { threadUnexpectedException(ie); }
276 }
277
278 /**
279 * isHeldExclusively is false upon construction
280 */
281 public void testIsHeldExclusively() {
282 Mutex sync = new Mutex();
283 assertFalse(sync.isHeldExclusively());
284 }
285
286 /**
287 * acquiring released sync succeeds
288 */
289 public void testAcquire() {
290 Mutex sync = new Mutex();
291 sync.acquire();
292 assertTrue(sync.isHeldExclusively());
293 sync.release();
294 assertFalse(sync.isHeldExclusively());
295 }
296
297 /**
298 * tryAcquire on a released sync succeeds
299 */
300 public void testTryAcquire() {
301 Mutex sync = new Mutex();
302 assertTrue(sync.tryAcquire());
303 assertTrue(sync.isHeldExclusively());
304 sync.release();
305 assertFalse(sync.isHeldExclusively());
306 }
307
308 /**
309 * hasQueuedThreads reports whether there are waiting threads
310 */
311 public void testHasQueuedThreads() {
312 final Mutex sync = new Mutex();
313 assertFalse(sync.hasQueuedThreads());
314 sync.acquire();
315 Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync));
316 waitForQueuedThread(sync, t1);
317 assertTrue(sync.hasQueuedThreads());
318 Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync));
319 waitForQueuedThread(sync, t2);
320 assertTrue(sync.hasQueuedThreads());
321 t1.interrupt();
322 awaitTermination(t1);
323 assertTrue(sync.hasQueuedThreads());
324 sync.release();
325 awaitTermination(t2);
326 assertFalse(sync.hasQueuedThreads());
327 }
328
329 /**
330 * isQueued(null) throws NullPointerException
331 */
332 public void testIsQueuedNPE() {
333 final Mutex sync = new Mutex();
334 try {
335 sync.isQueued(null);
336 shouldThrow();
337 } catch (NullPointerException success) {}
338 }
339
340 /**
341 * isQueued reports whether a thread is queued
342 */
343 public void testIsQueued() {
344 final Mutex sync = new Mutex();
345 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
346 Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
347 assertFalse(sync.isQueued(t1));
348 assertFalse(sync.isQueued(t2));
349 sync.acquire();
350 t1.start();
351 waitForQueuedThread(sync, t1);
352 assertTrue(sync.isQueued(t1));
353 assertFalse(sync.isQueued(t2));
354 t2.start();
355 waitForQueuedThread(sync, t2);
356 assertTrue(sync.isQueued(t1));
357 assertTrue(sync.isQueued(t2));
358 t1.interrupt();
359 awaitTermination(t1);
360 assertFalse(sync.isQueued(t1));
361 assertTrue(sync.isQueued(t2));
362 sync.release();
363 awaitTermination(t2);
364 assertFalse(sync.isQueued(t1));
365 assertFalse(sync.isQueued(t2));
366 }
367
368 /**
369 * getFirstQueuedThread returns first waiting thread or null if none
370 */
371 public void testGetFirstQueuedThread() {
372 final Mutex sync = new Mutex();
373 assertNull(sync.getFirstQueuedThread());
374 sync.acquire();
375 Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync));
376 waitForQueuedThread(sync, t1);
377 assertEquals(t1, sync.getFirstQueuedThread());
378 Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync));
379 waitForQueuedThread(sync, t2);
380 assertEquals(t1, sync.getFirstQueuedThread());
381 t1.interrupt();
382 awaitTermination(t1);
383 assertEquals(t2, sync.getFirstQueuedThread());
384 sync.release();
385 awaitTermination(t2);
386 assertNull(sync.getFirstQueuedThread());
387 }
388
389 /**
390 * hasContended reports false if no thread has ever blocked, else true
391 */
392 public void testHasContended() {
393 final Mutex sync = new Mutex();
394 assertFalse(sync.hasContended());
395 sync.acquire();
396 assertFalse(sync.hasContended());
397 Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync));
398 waitForQueuedThread(sync, t1);
399 assertTrue(sync.hasContended());
400 Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync));
401 waitForQueuedThread(sync, t2);
402 assertTrue(sync.hasContended());
403 t1.interrupt();
404 awaitTermination(t1);
405 assertTrue(sync.hasContended());
406 sync.release();
407 awaitTermination(t2);
408 assertTrue(sync.hasContended());
409 }
410
411 /**
412 * getQueuedThreads returns all waiting threads
413 */
414 public void testGetQueuedThreads() {
415 final Mutex sync = new Mutex();
416 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
417 Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
418 assertHasExclusiveQueuedThreads(sync, NO_THREADS);
419 sync.acquire();
420 assertHasExclusiveQueuedThreads(sync, NO_THREADS);
421 t1.start();
422 waitForQueuedThread(sync, t1);
423 assertHasExclusiveQueuedThreads(sync, t1);
424 assertTrue(sync.getQueuedThreads().contains(t1));
425 assertFalse(sync.getQueuedThreads().contains(t2));
426 t2.start();
427 waitForQueuedThread(sync, t2);
428 assertHasExclusiveQueuedThreads(sync, t1, t2);
429 assertTrue(sync.getQueuedThreads().contains(t1));
430 assertTrue(sync.getQueuedThreads().contains(t2));
431 t1.interrupt();
432 awaitTermination(t1);
433 assertHasExclusiveQueuedThreads(sync, t2);
434 sync.release();
435 awaitTermination(t2);
436 assertHasExclusiveQueuedThreads(sync, NO_THREADS);
437 }
438
439 /**
440 * getExclusiveQueuedThreads returns all exclusive waiting threads
441 */
442 public void testGetExclusiveQueuedThreads() {
443 final Mutex sync = new Mutex();
444 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
445 Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
446 assertHasExclusiveQueuedThreads(sync, NO_THREADS);
447 sync.acquire();
448 assertHasExclusiveQueuedThreads(sync, NO_THREADS);
449 t1.start();
450 waitForQueuedThread(sync, t1);
451 assertHasExclusiveQueuedThreads(sync, t1);
452 assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
453 assertFalse(sync.getExclusiveQueuedThreads().contains(t2));
454 t2.start();
455 waitForQueuedThread(sync, t2);
456 assertHasExclusiveQueuedThreads(sync, t1, t2);
457 assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
458 assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
459 t1.interrupt();
460 awaitTermination(t1);
461 assertHasExclusiveQueuedThreads(sync, t2);
462 sync.release();
463 awaitTermination(t2);
464 assertHasExclusiveQueuedThreads(sync, NO_THREADS);
465 }
466
467 /**
468 * getSharedQueuedThreads does not include exclusively waiting threads
469 */
470 public void testGetSharedQueuedThreads_Exclusive() {
471 final Mutex sync = new Mutex();
472 assertTrue(sync.getSharedQueuedThreads().isEmpty());
473 sync.acquire();
474 assertTrue(sync.getSharedQueuedThreads().isEmpty());
475 Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync));
476 waitForQueuedThread(sync, t1);
477 assertTrue(sync.getSharedQueuedThreads().isEmpty());
478 Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync));
479 waitForQueuedThread(sync, t2);
480 assertTrue(sync.getSharedQueuedThreads().isEmpty());
481 t1.interrupt();
482 awaitTermination(t1);
483 assertTrue(sync.getSharedQueuedThreads().isEmpty());
484 sync.release();
485 awaitTermination(t2);
486 assertTrue(sync.getSharedQueuedThreads().isEmpty());
487 }
488
489 /**
490 * getSharedQueuedThreads returns all shared waiting threads
491 */
492 public void testGetSharedQueuedThreads_Shared() {
493 final BooleanLatch l = new BooleanLatch();
494 assertHasSharedQueuedThreads(l, NO_THREADS);
495 Thread t1 = newStartedThread(new CheckedInterruptedRunnable() {
496 public void realRun() throws InterruptedException {
497 l.acquireSharedInterruptibly(0);
498 }});
499 waitForQueuedThread(l, t1);
500 assertHasSharedQueuedThreads(l, t1);
501 Thread t2 = newStartedThread(new CheckedRunnable() {
502 public void realRun() throws InterruptedException {
503 l.acquireSharedInterruptibly(0);
504 }});
505 waitForQueuedThread(l, t2);
506 assertHasSharedQueuedThreads(l, t1, t2);
507 t1.interrupt();
508 awaitTermination(t1);
509 assertHasSharedQueuedThreads(l, t2);
510 assertTrue(l.releaseShared(0));
511 awaitTermination(t2);
512 assertHasSharedQueuedThreads(l, NO_THREADS);
513 }
514
515 /**
516 * tryAcquireNanos is interruptible
517 */
518 public void testTryAcquireNanos_Interruptible() {
519 final Mutex sync = new Mutex();
520 sync.acquire();
521 Thread t = newStartedThread(new CheckedInterruptedRunnable() {
522 public void realRun() throws InterruptedException {
523 sync.tryAcquireNanos(MILLISECONDS.toNanos(2 * LONG_DELAY_MS));
524 }});
525
526 waitForQueuedThread(sync, t);
527 t.interrupt();
528 awaitTermination(t);
529 }
530
531 /**
532 * tryAcquire on exclusively held sync fails
533 */
534 public void testTryAcquireWhenSynced() {
535 final Mutex sync = new Mutex();
536 sync.acquire();
537 Thread t = newStartedThread(new CheckedRunnable() {
538 public void realRun() {
539 assertFalse(sync.tryAcquire());
540 }});
541
542 awaitTermination(t);
543 sync.release();
544 }
545
546 /**
547 * tryAcquireNanos on an exclusively held sync times out
548 */
549 public void testAcquireNanos_Timeout() {
550 final Mutex sync = new Mutex();
551 sync.acquire();
552 Thread t = newStartedThread(new CheckedRunnable() {
553 public void realRun() throws InterruptedException {
554 long startTime = System.nanoTime();
555 long nanos = MILLISECONDS.toNanos(timeoutMillis());
556 assertFalse(sync.tryAcquireNanos(nanos));
557 assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
558 }});
559
560 awaitTermination(t);
561 sync.release();
562 }
563
564 /**
565 * getState is true when acquired and false when not
566 */
567 public void testGetState() {
568 final Mutex sync = new Mutex();
569 sync.acquire();
570 assertTrue(sync.isHeldExclusively());
571 sync.release();
572 assertFalse(sync.isHeldExclusively());
573
574 final BooleanLatch acquired = new BooleanLatch();
575 final BooleanLatch done = new BooleanLatch();
576 Thread t = newStartedThread(new CheckedRunnable() {
577 public void realRun() throws InterruptedException {
578 sync.acquire();
579 assertTrue(acquired.releaseShared(0));
580 done.acquireShared(0);
581 sync.release();
582 }});
583
584 acquired.acquireShared(0);
585 assertTrue(sync.isHeldExclusively());
586 assertTrue(done.releaseShared(0));
587 awaitTermination(t);
588 assertFalse(sync.isHeldExclusively());
589 }
590
591 /**
592 * acquireInterruptibly succeeds when released, else is interruptible
593 */
594 public void testAcquireInterruptibly() throws InterruptedException {
595 final Mutex sync = new Mutex();
596 final BooleanLatch threadStarted = new BooleanLatch();
597 sync.acquireInterruptibly();
598 Thread t = newStartedThread(new CheckedInterruptedRunnable() {
599 public void realRun() throws InterruptedException {
600 assertTrue(threadStarted.releaseShared(0));
601 sync.acquireInterruptibly();
602 }});
603
604 threadStarted.acquireShared(0);
605 waitForQueuedThread(sync, t);
606 t.interrupt();
607 awaitTermination(t);
608 assertTrue(sync.isHeldExclusively());
609 }
610
611 /**
612 * owns is true for a condition created by sync else false
613 */
614 public void testOwns() {
615 final Mutex sync = new Mutex();
616 final ConditionObject c = sync.newCondition();
617 final Mutex sync2 = new Mutex();
618 assertTrue(sync.owns(c));
619 assertFalse(sync2.owns(c));
620 }
621
622 /**
623 * Calling await without holding sync throws IllegalMonitorStateException
624 */
625 public void testAwait_IMSE() {
626 final Mutex sync = new Mutex();
627 final ConditionObject c = sync.newCondition();
628 for (AwaitMethod awaitMethod : AwaitMethod.values()) {
629 long startTime = System.nanoTime();
630 try {
631 await(c, awaitMethod);
632 shouldThrow();
633 } catch (IllegalMonitorStateException success) {
634 } catch (InterruptedException e) { threadUnexpectedException(e); }
635 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
636 }
637 }
638
639 /**
640 * Calling signal without holding sync throws IllegalMonitorStateException
641 */
642 public void testSignal_IMSE() {
643 final Mutex sync = new Mutex();
644 final ConditionObject c = sync.newCondition();
645 try {
646 c.signal();
647 shouldThrow();
648 } catch (IllegalMonitorStateException success) {}
649 assertHasWaitersUnlocked(sync, c, NO_THREADS);
650 }
651
652 /**
653 * Calling signalAll without holding sync throws IllegalMonitorStateException
654 */
655 public void testSignalAll_IMSE() {
656 final Mutex sync = new Mutex();
657 final ConditionObject c = sync.newCondition();
658 try {
659 c.signalAll();
660 shouldThrow();
661 } catch (IllegalMonitorStateException success) {}
662 }
663
664 /**
665 * await/awaitNanos/awaitUntil without a signal times out
666 */
667 public void testAwaitTimed_Timeout() { testAwait_Timeout(AwaitMethod.awaitTimed); }
668 public void testAwaitNanos_Timeout() { testAwait_Timeout(AwaitMethod.awaitNanos); }
669 public void testAwaitUntil_Timeout() { testAwait_Timeout(AwaitMethod.awaitUntil); }
670 public void testAwait_Timeout(AwaitMethod awaitMethod) {
671 final Mutex sync = new Mutex();
672 final ConditionObject c = sync.newCondition();
673 sync.acquire();
674 assertAwaitTimesOut(c, awaitMethod);
675 sync.release();
676 }
677
678 /**
679 * await/awaitNanos/awaitUntil returns when signalled
680 */
681 public void testSignal_await() { testSignal(AwaitMethod.await); }
682 public void testSignal_awaitTimed() { testSignal(AwaitMethod.awaitTimed); }
683 public void testSignal_awaitNanos() { testSignal(AwaitMethod.awaitNanos); }
684 public void testSignal_awaitUntil() { testSignal(AwaitMethod.awaitUntil); }
685 public void testSignal(final AwaitMethod awaitMethod) {
686 final Mutex sync = new Mutex();
687 final ConditionObject c = sync.newCondition();
688 final BooleanLatch acquired = new BooleanLatch();
689 Thread t = newStartedThread(new CheckedRunnable() {
690 public void realRun() throws InterruptedException {
691 sync.acquire();
692 assertTrue(acquired.releaseShared(0));
693 await(c, awaitMethod);
694 sync.release();
695 }});
696
697 acquired.acquireShared(0);
698 sync.acquire();
699 assertHasWaitersLocked(sync, c, t);
700 assertHasExclusiveQueuedThreads(sync, NO_THREADS);
701 c.signal();
702 assertHasWaitersLocked(sync, c, NO_THREADS);
703 assertHasExclusiveQueuedThreads(sync, t);
704 sync.release();
705 awaitTermination(t);
706 }
707
708 /**
709 * hasWaiters(null) throws NullPointerException
710 */
711 public void testHasWaitersNPE() {
712 final Mutex sync = new Mutex();
713 try {
714 sync.hasWaiters(null);
715 shouldThrow();
716 } catch (NullPointerException success) {}
717 }
718
719 /**
720 * getWaitQueueLength(null) throws NullPointerException
721 */
722 public void testGetWaitQueueLengthNPE() {
723 final Mutex sync = new Mutex();
724 try {
725 sync.getWaitQueueLength(null);
726 shouldThrow();
727 } catch (NullPointerException success) {}
728 }
729
730 /**
731 * getWaitingThreads(null) throws NullPointerException
732 */
733 public void testGetWaitingThreadsNPE() {
734 final Mutex sync = new Mutex();
735 try {
736 sync.getWaitingThreads(null);
737 shouldThrow();
738 } catch (NullPointerException success) {}
739 }
740
741 /**
742 * hasWaiters throws IllegalArgumentException if not owned
743 */
744 public void testHasWaitersIAE() {
745 final Mutex sync = new Mutex();
746 final ConditionObject c = sync.newCondition();
747 final Mutex sync2 = new Mutex();
748 try {
749 sync2.hasWaiters(c);
750 shouldThrow();
751 } catch (IllegalArgumentException success) {}
752 assertHasWaitersUnlocked(sync, c, NO_THREADS);
753 }
754
755 /**
756 * hasWaiters throws IllegalMonitorStateException if not synced
757 */
758 public void testHasWaitersIMSE() {
759 final Mutex sync = new Mutex();
760 final ConditionObject c = sync.newCondition();
761 try {
762 sync.hasWaiters(c);
763 shouldThrow();
764 } catch (IllegalMonitorStateException success) {}
765 assertHasWaitersUnlocked(sync, c, NO_THREADS);
766 }
767
768 /**
769 * getWaitQueueLength throws IllegalArgumentException if not owned
770 */
771 public void testGetWaitQueueLengthIAE() {
772 final Mutex sync = new Mutex();
773 final ConditionObject c = sync.newCondition();
774 final Mutex sync2 = new Mutex();
775 try {
776 sync2.getWaitQueueLength(c);
777 shouldThrow();
778 } catch (IllegalArgumentException success) {}
779 assertHasWaitersUnlocked(sync, c, NO_THREADS);
780 }
781
782 /**
783 * getWaitQueueLength throws IllegalMonitorStateException if not synced
784 */
785 public void testGetWaitQueueLengthIMSE() {
786 final Mutex sync = new Mutex();
787 final ConditionObject c = sync.newCondition();
788 try {
789 sync.getWaitQueueLength(c);
790 shouldThrow();
791 } catch (IllegalMonitorStateException success) {}
792 assertHasWaitersUnlocked(sync, c, NO_THREADS);
793 }
794
795 /**
796 * getWaitingThreads throws IllegalArgumentException if not owned
797 */
798 public void testGetWaitingThreadsIAE() {
799 final Mutex sync = new Mutex();
800 final ConditionObject c = sync.newCondition();
801 final Mutex sync2 = new Mutex();
802 try {
803 sync2.getWaitingThreads(c);
804 shouldThrow();
805 } catch (IllegalArgumentException success) {}
806 assertHasWaitersUnlocked(sync, c, NO_THREADS);
807 }
808
809 /**
810 * getWaitingThreads throws IllegalMonitorStateException if not synced
811 */
812 public void testGetWaitingThreadsIMSE() {
813 final Mutex sync = new Mutex();
814 final ConditionObject c = sync.newCondition();
815 try {
816 sync.getWaitingThreads(c);
817 shouldThrow();
818 } catch (IllegalMonitorStateException success) {}
819 assertHasWaitersUnlocked(sync, c, NO_THREADS);
820 }
821
822 /**
823 * hasWaiters returns true when a thread is waiting, else false
824 */
825 public void testHasWaiters() {
826 final Mutex sync = new Mutex();
827 final ConditionObject c = sync.newCondition();
828 final BooleanLatch acquired = new BooleanLatch();
829 Thread t = newStartedThread(new CheckedRunnable() {
830 public void realRun() throws InterruptedException {
831 sync.acquire();
832 assertHasWaitersLocked(sync, c, NO_THREADS);
833 assertFalse(sync.hasWaiters(c));
834 assertTrue(acquired.releaseShared(0));
835 c.await();
836 sync.release();
837 }});
838
839 acquired.acquireShared(0);
840 sync.acquire();
841 assertHasWaitersLocked(sync, c, t);
842 assertHasExclusiveQueuedThreads(sync, NO_THREADS);
843 assertTrue(sync.hasWaiters(c));
844 c.signal();
845 assertHasWaitersLocked(sync, c, NO_THREADS);
846 assertHasExclusiveQueuedThreads(sync, t);
847 assertFalse(sync.hasWaiters(c));
848 sync.release();
849
850 awaitTermination(t);
851 assertHasWaitersUnlocked(sync, c, NO_THREADS);
852 }
853
854 /**
855 * getWaitQueueLength returns number of waiting threads
856 */
857 public void testGetWaitQueueLength() {
858 final Mutex sync = new Mutex();
859 final ConditionObject c = sync.newCondition();
860 final BooleanLatch acquired1 = new BooleanLatch();
861 final BooleanLatch acquired2 = new BooleanLatch();
862 final Thread t1 = newStartedThread(new CheckedRunnable() {
863 public void realRun() throws InterruptedException {
864 sync.acquire();
865 assertHasWaitersLocked(sync, c, NO_THREADS);
866 assertEquals(0, sync.getWaitQueueLength(c));
867 assertTrue(acquired1.releaseShared(0));
868 c.await();
869 sync.release();
870 }});
871 acquired1.acquireShared(0);
872 sync.acquire();
873 assertHasWaitersLocked(sync, c, t1);
874 assertEquals(1, sync.getWaitQueueLength(c));
875 sync.release();
876
877 final Thread t2 = newStartedThread(new CheckedRunnable() {
878 public void realRun() throws InterruptedException {
879 sync.acquire();
880 assertHasWaitersLocked(sync, c, t1);
881 assertEquals(1, sync.getWaitQueueLength(c));
882 assertTrue(acquired2.releaseShared(0));
883 c.await();
884 sync.release();
885 }});
886 acquired2.acquireShared(0);
887 sync.acquire();
888 assertHasWaitersLocked(sync, c, t1, t2);
889 assertHasExclusiveQueuedThreads(sync, NO_THREADS);
890 assertEquals(2, sync.getWaitQueueLength(c));
891 c.signalAll();
892 assertHasWaitersLocked(sync, c, NO_THREADS);
893 assertHasExclusiveQueuedThreads(sync, t1, t2);
894 assertEquals(0, sync.getWaitQueueLength(c));
895 sync.release();
896
897 awaitTermination(t1);
898 awaitTermination(t2);
899 assertHasWaitersUnlocked(sync, c, NO_THREADS);
900 }
901
902 /**
903 * getWaitingThreads returns only and all waiting threads
904 */
905 public void testGetWaitingThreads() {
906 final Mutex sync = new Mutex();
907 final ConditionObject c = sync.newCondition();
908 final BooleanLatch acquired1 = new BooleanLatch();
909 final BooleanLatch acquired2 = new BooleanLatch();
910 final Thread t1 = new Thread(new CheckedRunnable() {
911 public void realRun() throws InterruptedException {
912 sync.acquire();
913 assertHasWaitersLocked(sync, c, NO_THREADS);
914 assertTrue(sync.getWaitingThreads(c).isEmpty());
915 assertTrue(acquired1.releaseShared(0));
916 c.await();
917 sync.release();
918 }});
919
920 final Thread t2 = new Thread(new CheckedRunnable() {
921 public void realRun() throws InterruptedException {
922 sync.acquire();
923 assertHasWaitersLocked(sync, c, t1);
924 assertTrue(sync.getWaitingThreads(c).contains(t1));
925 assertFalse(sync.getWaitingThreads(c).isEmpty());
926 assertEquals(1, sync.getWaitingThreads(c).size());
927 assertTrue(acquired2.releaseShared(0));
928 c.await();
929 sync.release();
930 }});
931
932 sync.acquire();
933 assertHasWaitersLocked(sync, c, NO_THREADS);
934 assertFalse(sync.getWaitingThreads(c).contains(t1));
935 assertFalse(sync.getWaitingThreads(c).contains(t2));
936 assertTrue(sync.getWaitingThreads(c).isEmpty());
937 assertEquals(0, sync.getWaitingThreads(c).size());
938 sync.release();
939
940 t1.start();
941 acquired1.acquireShared(0);
942 sync.acquire();
943 assertHasWaitersLocked(sync, c, t1);
944 assertTrue(sync.getWaitingThreads(c).contains(t1));
945 assertFalse(sync.getWaitingThreads(c).contains(t2));
946 assertFalse(sync.getWaitingThreads(c).isEmpty());
947 assertEquals(1, sync.getWaitingThreads(c).size());
948 sync.release();
949
950 t2.start();
951 acquired2.acquireShared(0);
952 sync.acquire();
953 assertHasWaitersLocked(sync, c, t1, t2);
954 assertHasExclusiveQueuedThreads(sync, NO_THREADS);
955 assertTrue(sync.getWaitingThreads(c).contains(t1));
956 assertTrue(sync.getWaitingThreads(c).contains(t2));
957 assertFalse(sync.getWaitingThreads(c).isEmpty());
958 assertEquals(2, sync.getWaitingThreads(c).size());
959 c.signalAll();
960 assertHasWaitersLocked(sync, c, NO_THREADS);
961 assertHasExclusiveQueuedThreads(sync, t1, t2);
962 assertFalse(sync.getWaitingThreads(c).contains(t1));
963 assertFalse(sync.getWaitingThreads(c).contains(t2));
964 assertTrue(sync.getWaitingThreads(c).isEmpty());
965 assertEquals(0, sync.getWaitingThreads(c).size());
966 sync.release();
967
968 awaitTermination(t1);
969 awaitTermination(t2);
970 assertHasWaitersUnlocked(sync, c, NO_THREADS);
971 }
972
973 /**
974 * awaitUninterruptibly is uninterruptible
975 */
976 public void testAwaitUninterruptibly() {
977 final Mutex sync = new Mutex();
978 final ConditionObject condition = sync.newCondition();
979 final BooleanLatch pleaseInterrupt = new BooleanLatch();
980 Thread t = newStartedThread(new CheckedRunnable() {
981 public void realRun() {
982 sync.acquire();
983 assertTrue(pleaseInterrupt.releaseShared(0));
984 condition.awaitUninterruptibly();
985 assertTrue(Thread.interrupted());
986 assertHasWaitersLocked(sync, condition, NO_THREADS);
987 sync.release();
988 }});
989
990 pleaseInterrupt.acquireShared(0);
991 sync.acquire();
992 assertHasWaitersLocked(sync, condition, t);
993 sync.release();
994 t.interrupt();
995 assertHasWaitersUnlocked(sync, condition, t);
996 assertThreadBlocks(t, Thread.State.WAITING);
997 sync.acquire();
998 assertHasWaitersLocked(sync, condition, t);
999 assertHasExclusiveQueuedThreads(sync, NO_THREADS);
1000 condition.signal();
1001 assertHasWaitersLocked(sync, condition, NO_THREADS);
1002 assertHasExclusiveQueuedThreads(sync, t);
1003 sync.release();
1004 awaitTermination(t);
1005 }
1006
1007 /**
1008 * await/awaitNanos/awaitUntil is interruptible
1009 */
1010 public void testInterruptible_await() { testInterruptible(AwaitMethod.await); }
1011 public void testInterruptible_awaitTimed() { testInterruptible(AwaitMethod.awaitTimed); }
1012 public void testInterruptible_awaitNanos() { testInterruptible(AwaitMethod.awaitNanos); }
1013 public void testInterruptible_awaitUntil() { testInterruptible(AwaitMethod.awaitUntil); }
1014 public void testInterruptible(final AwaitMethod awaitMethod) {
1015 final Mutex sync = new Mutex();
1016 final ConditionObject c = sync.newCondition();
1017 final BooleanLatch pleaseInterrupt = new BooleanLatch();
1018 Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1019 public void realRun() throws InterruptedException {
1020 sync.acquire();
1021 assertTrue(pleaseInterrupt.releaseShared(0));
1022 await(c, awaitMethod);
1023 }});
1024
1025 pleaseInterrupt.acquireShared(0);
1026 t.interrupt();
1027 awaitTermination(t);
1028 }
1029
1030 /**
1031 * signalAll wakes up all threads
1032 */
1033 public void testSignalAll_await() { testSignalAll(AwaitMethod.await); }
1034 public void testSignalAll_awaitTimed() { testSignalAll(AwaitMethod.awaitTimed); }
1035 public void testSignalAll_awaitNanos() { testSignalAll(AwaitMethod.awaitNanos); }
1036 public void testSignalAll_awaitUntil() { testSignalAll(AwaitMethod.awaitUntil); }
1037 public void testSignalAll(final AwaitMethod awaitMethod) {
1038 final Mutex sync = new Mutex();
1039 final ConditionObject c = sync.newCondition();
1040 final BooleanLatch acquired1 = new BooleanLatch();
1041 final BooleanLatch acquired2 = new BooleanLatch();
1042 Thread t1 = newStartedThread(new CheckedRunnable() {
1043 public void realRun() throws InterruptedException {
1044 sync.acquire();
1045 acquired1.releaseShared(0);
1046 await(c, awaitMethod);
1047 sync.release();
1048 }});
1049
1050 Thread t2 = newStartedThread(new CheckedRunnable() {
1051 public void realRun() throws InterruptedException {
1052 sync.acquire();
1053 acquired2.releaseShared(0);
1054 await(c, awaitMethod);
1055 sync.release();
1056 }});
1057
1058 acquired1.acquireShared(0);
1059 acquired2.acquireShared(0);
1060 sync.acquire();
1061 assertHasWaitersLocked(sync, c, t1, t2);
1062 assertHasExclusiveQueuedThreads(sync, NO_THREADS);
1063 c.signalAll();
1064 assertHasWaitersLocked(sync, c, NO_THREADS);
1065 assertHasExclusiveQueuedThreads(sync, t1, t2);
1066 sync.release();
1067 awaitTermination(t1);
1068 awaitTermination(t2);
1069 }
1070
1071 /**
1072 * toString indicates current state
1073 */
1074 public void testToString() {
1075 Mutex sync = new Mutex();
1076 assertTrue(sync.toString().contains("State = " + Mutex.UNLOCKED));
1077 sync.acquire();
1078 assertTrue(sync.toString().contains("State = " + Mutex.LOCKED));
1079 }
1080
1081 /**
1082 * A serialized AQS deserializes with current state, but no queued threads
1083 */
1084 public void testSerialization() {
1085 Mutex sync = new Mutex();
1086 assertFalse(serialClone(sync).isHeldExclusively());
1087 sync.acquire();
1088 Thread t = newStartedThread(new InterruptedSyncRunnable(sync));
1089 waitForQueuedThread(sync, t);
1090 assertTrue(sync.isHeldExclusively());
1091
1092 Mutex clone = serialClone(sync);
1093 assertTrue(clone.isHeldExclusively());
1094 assertHasExclusiveQueuedThreads(sync, t);
1095 assertHasExclusiveQueuedThreads(clone, NO_THREADS);
1096 t.interrupt();
1097 awaitTermination(t);
1098 sync.release();
1099 assertFalse(sync.isHeldExclusively());
1100 assertTrue(clone.isHeldExclusively());
1101 assertHasExclusiveQueuedThreads(sync, NO_THREADS);
1102 assertHasExclusiveQueuedThreads(clone, NO_THREADS);
1103 }
1104
1105 /**
1106 * tryReleaseShared setting state changes getState
1107 */
1108 public void testGetStateWithReleaseShared() {
1109 final BooleanLatch l = new BooleanLatch();
1110 assertFalse(l.isSignalled());
1111 assertTrue(l.releaseShared(0));
1112 assertTrue(l.isSignalled());
1113 }
1114
1115 /**
1116 * releaseShared has no effect when already signalled
1117 */
1118 public void testReleaseShared() {
1119 final BooleanLatch l = new BooleanLatch();
1120 assertFalse(l.isSignalled());
1121 assertTrue(l.releaseShared(0));
1122 assertTrue(l.isSignalled());
1123 assertTrue(l.releaseShared(0));
1124 assertTrue(l.isSignalled());
1125 }
1126
1127 /**
1128 * acquireSharedInterruptibly returns after release, but not before
1129 */
1130 public void testAcquireSharedInterruptibly() {
1131 final BooleanLatch l = new BooleanLatch();
1132
1133 Thread t = newStartedThread(new CheckedRunnable() {
1134 public void realRun() throws InterruptedException {
1135 assertFalse(l.isSignalled());
1136 l.acquireSharedInterruptibly(0);
1137 assertTrue(l.isSignalled());
1138 l.acquireSharedInterruptibly(0);
1139 assertTrue(l.isSignalled());
1140 }});
1141
1142 waitForQueuedThread(l, t);
1143 assertFalse(l.isSignalled());
1144 assertThreadBlocks(t, Thread.State.WAITING);
1145 assertHasSharedQueuedThreads(l, t);
1146 assertTrue(l.releaseShared(0));
1147 assertTrue(l.isSignalled());
1148 awaitTermination(t);
1149 }
1150
1151 /**
1152 * tryAcquireSharedNanos returns after release, but not before
1153 */
1154 public void testTryAcquireSharedNanos() {
1155 final BooleanLatch l = new BooleanLatch();
1156
1157 Thread t = newStartedThread(new CheckedRunnable() {
1158 public void realRun() throws InterruptedException {
1159 assertFalse(l.isSignalled());
1160 long nanos = MILLISECONDS.toNanos(2 * LONG_DELAY_MS);
1161 assertTrue(l.tryAcquireSharedNanos(0, nanos));
1162 assertTrue(l.isSignalled());
1163 assertTrue(l.tryAcquireSharedNanos(0, nanos));
1164 assertTrue(l.isSignalled());
1165 }});
1166
1167 waitForQueuedThread(l, t);
1168 assertFalse(l.isSignalled());
1169 assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1170 assertTrue(l.releaseShared(0));
1171 assertTrue(l.isSignalled());
1172 awaitTermination(t);
1173 }
1174
1175 /**
1176 * acquireSharedInterruptibly is interruptible
1177 */
1178 public void testAcquireSharedInterruptibly_Interruptible() {
1179 final BooleanLatch l = new BooleanLatch();
1180 Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1181 public void realRun() throws InterruptedException {
1182 assertFalse(l.isSignalled());
1183 l.acquireSharedInterruptibly(0);
1184 }});
1185
1186 waitForQueuedThread(l, t);
1187 assertFalse(l.isSignalled());
1188 t.interrupt();
1189 awaitTermination(t);
1190 assertFalse(l.isSignalled());
1191 }
1192
1193 /**
1194 * tryAcquireSharedNanos is interruptible
1195 */
1196 public void testTryAcquireSharedNanos_Interruptible() {
1197 final BooleanLatch l = new BooleanLatch();
1198 Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1199 public void realRun() throws InterruptedException {
1200 assertFalse(l.isSignalled());
1201 long nanos = MILLISECONDS.toNanos(2 * LONG_DELAY_MS);
1202 l.tryAcquireSharedNanos(0, nanos);
1203 }});
1204
1205 waitForQueuedThread(l, t);
1206 assertFalse(l.isSignalled());
1207 t.interrupt();
1208 awaitTermination(t);
1209 assertFalse(l.isSignalled());
1210 }
1211
1212 /**
1213 * tryAcquireSharedNanos times out if not released before timeout
1214 */
1215 public void testTryAcquireSharedNanos_Timeout() {
1216 final BooleanLatch l = new BooleanLatch();
1217 final BooleanLatch observedQueued = new BooleanLatch();
1218 Thread t = newStartedThread(new CheckedRunnable() {
1219 public void realRun() throws InterruptedException {
1220 assertFalse(l.isSignalled());
1221 for (long millis = timeoutMillis();
1222 !observedQueued.isSignalled();
1223 millis *= 2) {
1224 long nanos = MILLISECONDS.toNanos(millis);
1225 long startTime = System.nanoTime();
1226 assertFalse(l.tryAcquireSharedNanos(0, nanos));
1227 assertTrue(millisElapsedSince(startTime) >= millis);
1228 }
1229 assertFalse(l.isSignalled());
1230 }});
1231
1232 waitForQueuedThread(l, t);
1233 observedQueued.releaseShared(0);
1234 assertFalse(l.isSignalled());
1235 awaitTermination(t);
1236 assertFalse(l.isSignalled());
1237 }
1238
1239 /**
1240 * awaitNanos/timed await with 0 wait times out immediately
1241 */
1242 public void testAwait_Zero() throws InterruptedException {
1243 final Mutex sync = new Mutex();
1244 final ConditionObject c = sync.newCondition();
1245 sync.acquire();
1246 assertTrue(c.awaitNanos(0L) <= 0);
1247 assertFalse(c.await(0L, NANOSECONDS));
1248 sync.release();
1249 }
1250
1251 /**
1252 * awaitNanos/timed await with maximum negative wait times does not underflow
1253 */
1254 public void testAwait_NegativeInfinity() throws InterruptedException {
1255 final Mutex sync = new Mutex();
1256 final ConditionObject c = sync.newCondition();
1257 sync.acquire();
1258 assertTrue(c.awaitNanos(Long.MIN_VALUE) <= 0);
1259 assertFalse(c.await(Long.MIN_VALUE, NANOSECONDS));
1260 sync.release();
1261 }
1262
1263 /**
1264 * JDK-8191483: AbstractQueuedSynchronizer cancel/cancel race
1265 * ant -Djsr166.tckTestClass=AbstractQueuedSynchronizerTest -Djsr166.methodFilter=testCancelCancelRace -Djsr166.runsPerTest=100 tck
1266 */
1267 public void testCancelCancelRace() throws InterruptedException {
1268 class Sync extends AbstractQueuedSynchronizer {
1269 protected boolean tryAcquire(int acquires) {
1270 return !hasQueuedPredecessors() && compareAndSetState(0, 1);
1271 }
1272 protected boolean tryRelease(int releases) {
1273 return compareAndSetState(1, 0);
1274 }
1275 }
1276
1277 Sync s = new Sync();
1278 s.acquire(1); // acquire to force other threads to enqueue
1279
1280 // try to trigger double cancel race with two background threads
1281 ArrayList<Thread> threads = new ArrayList<>();
1282 Runnable failedAcquire = () -> {
1283 try {
1284 s.acquireInterruptibly(1);
1285 shouldThrow();
1286 } catch (InterruptedException expected) {}
1287 };
1288 for (int i = 0; i < 2; i++) {
1289 Thread thread = new Thread(failedAcquire);
1290 thread.start();
1291 threads.add(thread);
1292 }
1293 Thread.sleep(100);
1294 for (Thread thread : threads) thread.interrupt();
1295 for (Thread thread : threads) awaitTermination(thread);
1296
1297 s.release(1);
1298
1299 // no one holds lock now, we should be able to acquire
1300 if (!s.tryAcquire(1))
1301 throw new RuntimeException(
1302 String.format(
1303 "Broken: hasQueuedPredecessors=%s hasQueuedThreads=%s queueLength=%d firstQueuedThread=%s",
1304 s.hasQueuedPredecessors(),
1305 s.hasQueuedThreads(),
1306 s.getQueueLength(),
1307 s.getFirstQueuedThread()));
1308 }
1309
1310 /**
1311 * Tests scenario for
1312 * JDK-8191937: Lost interrupt in AbstractQueuedSynchronizer when tryAcquire methods throw
1313 */
1314 public void testInterruptedFailingAcquire() throws InterruptedException {
1315 final RuntimeException ex = new RuntimeException();
1316
1317 // A synchronizer only offering a choice of failure modes
1318 class Sync extends AbstractQueuedSynchronizer {
1319 boolean pleaseThrow;
1320 @Override protected boolean tryAcquire(int ignored) {
1321 if (pleaseThrow) throw ex;
1322 return false;
1323 }
1324 @Override protected int tryAcquireShared(int ignored) {
1325 if (pleaseThrow) throw ex;
1326 return -1;
1327 }
1328 @Override protected boolean tryRelease(int ignored) {
1329 return true;
1330 }
1331 @Override protected boolean tryReleaseShared(int ignored) {
1332 return true;
1333 }
1334 }
1335
1336 final Sync s = new Sync();
1337
1338 final Thread thread = newStartedThread(new CheckedRunnable() {
1339 public void realRun() {
1340 try {
1341 if (ThreadLocalRandom.current().nextBoolean())
1342 s.acquire(1);
1343 else
1344 s.acquireShared(1);
1345 shouldThrow();
1346 } catch (Throwable t) {
1347 assertSame(ex, t);
1348 assertTrue(Thread.interrupted());
1349 }
1350 }});
1351 waitForThreadToEnterWaitState(thread);
1352 assertSame(thread, s.getFirstQueuedThread());
1353 assertTrue(s.hasQueuedPredecessors());
1354 assertTrue(s.hasQueuedThreads());
1355 assertEquals(1, s.getQueueLength());
1356
1357 s.pleaseThrow = true;
1358 thread.interrupt();
1359 s.release(1);
1360 awaitTermination(thread);
1361 }
1362
1363 }

dl@cs.oswego.edu
ViewVC Help
Powered by ViewVC 1.1.27