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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.32, Mon Nov 30 08:31:09 2009 UTC revision 1.63, Tue Jan 23 20:44:11 2018 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at   * Expert Group and released to the public domain, as explained at
4   * http://creativecommons.org/licenses/publicdomain   * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.   * Pat Fisher, Mike Judd.
7   */   */
8    
   
 import junit.framework.*;  
 import java.util.*;  
 import java.util.concurrent.*;  
9  import static java.util.concurrent.TimeUnit.MILLISECONDS;  import static java.util.concurrent.TimeUnit.MILLISECONDS;
10  import java.util.concurrent.locks.*;  import static java.util.concurrent.TimeUnit.NANOSECONDS;
11  import java.io.*;  
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 {  public class AbstractQueuedSynchronizerTest extends JSR166TestCase {
25      public static void main(String[] args) {      public static void main(String[] args) {
26          junit.textui.TestRunner.run (suite());          main(suite(), args);
27      }      }
28      public static Test suite() {      public static Test suite() {
29          return new TestSuite(AbstractQueuedSynchronizerTest.class);          return new TestSuite(AbstractQueuedSynchronizerTest.class);
30      }      }
31    
32      /**      /**
33       * A simple mutex class, adapted from the       * A simple mutex class, adapted from the class javadoc.  Exclusive
34       * AbstractQueuedSynchronizer javadoc.  Exclusive acquire tests       * acquire tests exercise this as a sample user extension.  Other
35       * exercise this as a sample user extension.  Other       * methods/features of AbstractQueuedSynchronizer are tested via
36       * methods/features of AbstractQueuedSynchronizerTest are tested       * other test classes, including those for ReentrantLock,
37       * via other test classes, including those for ReentrantLock,       * ReentrantReadWriteLock, and Semaphore.
38       * ReentrantReadWriteLock, and Semaphore       *
39         * Unlike the javadoc sample, we don't track owner thread via
40         * AbstractOwnableSynchronizer methods.
41       */       */
42      static class Mutex extends AbstractQueuedSynchronizer {      static class Mutex extends AbstractQueuedSynchronizer {
43          public boolean isHeldExclusively() { return getState() == 1; }          /** 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          public boolean tryAcquire(int acquires) {          /** Owner thread is untracked, so this is really just isLocked(). */
49              assertTrue(acquires == 1);          @Override public boolean isHeldExclusively() {
50              return compareAndSetState(0, 1);              int state = getState();
51                assertTrue(state == UNLOCKED || state == LOCKED);
52                return state == LOCKED;
53          }          }
54    
55          public boolean tryRelease(int releases) {          @Override protected boolean tryAcquire(int acquires) {
56              if (getState() == 0) throw new IllegalMonitorStateException();              assertEquals(LOCKED, acquires);
57              setState(0);              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;              return true;
65          }          }
66    
67          public AbstractQueuedSynchronizer.ConditionObject newCondition() { return new AbstractQueuedSynchronizer.ConditionObject(); }          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 simple latch class, to test shared mode.       * A minimal latch class, to test shared mode.
99       */       */
100      static class BooleanLatch extends AbstractQueuedSynchronizer {      static class BooleanLatch extends AbstractQueuedSynchronizer {
101          public boolean isSignalled() { return getState() != 0; }          public boolean isSignalled() { return getState() != 0; }
# Line 71  Line 116 
116       */       */
117      class InterruptibleSyncRunnable extends CheckedRunnable {      class InterruptibleSyncRunnable extends CheckedRunnable {
118          final Mutex sync;          final Mutex sync;
119          InterruptibleSyncRunnable(Mutex l) { sync = l; }          InterruptibleSyncRunnable(Mutex sync) { this.sync = sync; }
120          public void realRun() throws InterruptedException {          public void realRun() throws InterruptedException {
121              sync.acquireInterruptibly(1);              sync.acquireInterruptibly();
122          }          }
123      }      }
124    
   
125      /**      /**
126       * A runnable calling acquireInterruptibly that expects to be       * A runnable calling acquireInterruptibly that expects to be
127       * interrupted.       * interrupted.
128       */       */
129      class InterruptedSyncRunnable extends CheckedInterruptedRunnable {      class InterruptedSyncRunnable extends CheckedInterruptedRunnable {
130          final Mutex sync;          final Mutex sync;
131          InterruptedSyncRunnable(Mutex l) { sync = l; }          InterruptedSyncRunnable(Mutex sync) { this.sync = sync; }
132          public void realRun() throws InterruptedException {          public void realRun() throws InterruptedException {
133              sync.acquireInterruptibly(1);              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 nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
232                long nanosRemaining = c.awaitNanos(nanosTimeout);
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 nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
260                    long nanosRemaining = c.awaitNanos(nanosTimeout);
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       * isHeldExclusively is false upon construction
280       */       */
281      public void testIsHeldExclusively() {      public void testIsHeldExclusively() {
282          Mutex rl = new Mutex();          Mutex sync = new Mutex();
283          assertFalse(rl.isHeldExclusively());          assertFalse(sync.isHeldExclusively());
284      }      }
285    
286      /**      /**
287       * acquiring released sync succeeds       * acquiring released sync succeeds
288       */       */
289      public void testAcquire() {      public void testAcquire() {
290          Mutex rl = new Mutex();          Mutex sync = new Mutex();
291          rl.acquire(1);          sync.acquire();
292          assertTrue(rl.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
293          rl.release(1);          sync.release();
294          assertFalse(rl.isHeldExclusively());          assertFalse(sync.isHeldExclusively());
295      }      }
296    
297      /**      /**
298       * tryAcquire on an released sync succeeds       * tryAcquire on a released sync succeeds
299       */       */
300      public void testTryAcquire() {      public void testTryAcquire() {
301          Mutex rl = new Mutex();          Mutex sync = new Mutex();
302          assertTrue(rl.tryAcquire(1));          assertTrue(sync.tryAcquire());
303          assertTrue(rl.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
304          rl.release(1);          sync.release();
305            assertFalse(sync.isHeldExclusively());
306      }      }
307    
308      /**      /**
309       * hasQueuedThreads reports whether there are waiting threads       * hasQueuedThreads reports whether there are waiting threads
310       */       */
311      public void testhasQueuedThreads() throws InterruptedException {      public void testHasQueuedThreads() {
312          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
         Thread t1 = new Thread(new InterruptedSyncRunnable(sync));  
         Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));  
313          assertFalse(sync.hasQueuedThreads());          assertFalse(sync.hasQueuedThreads());
314          sync.acquire(1);          sync.acquire();
315          t1.start();          Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync));
316          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t1);
317          assertTrue(sync.hasQueuedThreads());          assertTrue(sync.hasQueuedThreads());
318          t2.start();          Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync));
319          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t2);
320          assertTrue(sync.hasQueuedThreads());          assertTrue(sync.hasQueuedThreads());
321          t1.interrupt();          t1.interrupt();
322          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t1);
323          assertTrue(sync.hasQueuedThreads());          assertTrue(sync.hasQueuedThreads());
324          sync.release(1);          sync.release();
325          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t2);
326          assertFalse(sync.hasQueuedThreads());          assertFalse(sync.hasQueuedThreads());
         t1.join();  
         t2.join();  
327      }      }
328    
329      /**      /**
330       * isQueued(null) throws NPE       * isQueued(null) throws NullPointerException
331       */       */
332      public void testIsQueuedNPE() {      public void testIsQueuedNPE() {
333          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
# Line 156  Line 338 
338      }      }
339    
340      /**      /**
341       * isQueued reports whether a thread is queued.       * isQueued reports whether a thread is queued
342       */       */
343      public void testIsQueued() throws InterruptedException {      public void testIsQueued() {
344          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
345          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
346          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
347          assertFalse(sync.isQueued(t1));          assertFalse(sync.isQueued(t1));
348          assertFalse(sync.isQueued(t2));          assertFalse(sync.isQueued(t2));
349          sync.acquire(1);          sync.acquire();
350          t1.start();          t1.start();
351          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t1);
352          assertTrue(sync.isQueued(t1));          assertTrue(sync.isQueued(t1));
353            assertFalse(sync.isQueued(t2));
354          t2.start();          t2.start();
355          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t2);
356          assertTrue(sync.isQueued(t1));          assertTrue(sync.isQueued(t1));
357          assertTrue(sync.isQueued(t2));          assertTrue(sync.isQueued(t2));
358          t1.interrupt();          t1.interrupt();
359          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t1);
360          assertFalse(sync.isQueued(t1));          assertFalse(sync.isQueued(t1));
361          assertTrue(sync.isQueued(t2));          assertTrue(sync.isQueued(t2));
362          sync.release(1);          sync.release();
363          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t2);
364          assertFalse(sync.isQueued(t1));          assertFalse(sync.isQueued(t1));
         Thread.sleep(SHORT_DELAY_MS);  
365          assertFalse(sync.isQueued(t2));          assertFalse(sync.isQueued(t2));
         t1.join();  
         t2.join();  
366      }      }
367    
368      /**      /**
369       * getFirstQueuedThread returns first waiting thread or null if none       * getFirstQueuedThread returns first waiting thread or null if none
370       */       */
371      public void testGetFirstQueuedThread() throws InterruptedException {      public void testGetFirstQueuedThread() {
372          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
         Thread t1 = new Thread(new InterruptedSyncRunnable(sync));  
         Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));  
373          assertNull(sync.getFirstQueuedThread());          assertNull(sync.getFirstQueuedThread());
374          sync.acquire(1);          sync.acquire();
375          t1.start();          Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync));
376          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t1);
377          assertEquals(t1, sync.getFirstQueuedThread());          assertEquals(t1, sync.getFirstQueuedThread());
378          t2.start();          Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync));
379          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t2);
380          assertEquals(t1, sync.getFirstQueuedThread());          assertEquals(t1, sync.getFirstQueuedThread());
381          t1.interrupt();          t1.interrupt();
382          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t1);
         Thread.sleep(SHORT_DELAY_MS);  
383          assertEquals(t2, sync.getFirstQueuedThread());          assertEquals(t2, sync.getFirstQueuedThread());
384          sync.release(1);          sync.release();
385          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t2);
386          assertNull(sync.getFirstQueuedThread());          assertNull(sync.getFirstQueuedThread());
         t1.join();  
         t2.join();  
387      }      }
388    
   
389      /**      /**
390       * hasContended reports false if no thread has ever blocked, else true       * hasContended reports false if no thread has ever blocked, else true
391       */       */
392      public void testHasContended() throws InterruptedException {      public void testHasContended() {
393          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
         Thread t1 = new Thread(new InterruptedSyncRunnable(sync));  
         Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));  
394          assertFalse(sync.hasContended());          assertFalse(sync.hasContended());
395          sync.acquire(1);          sync.acquire();
396          t1.start();          assertFalse(sync.hasContended());
397          Thread.sleep(SHORT_DELAY_MS);          Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync));
398            waitForQueuedThread(sync, t1);
399          assertTrue(sync.hasContended());          assertTrue(sync.hasContended());
400          t2.start();          Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync));
401          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t2);
402          assertTrue(sync.hasContended());          assertTrue(sync.hasContended());
403          t1.interrupt();          t1.interrupt();
404          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t1);
405          assertTrue(sync.hasContended());          assertTrue(sync.hasContended());
406          sync.release(1);          sync.release();
407          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t2);
408          assertTrue(sync.hasContended());          assertTrue(sync.hasContended());
         t1.join();  
         t2.join();  
409      }      }
410    
411      /**      /**
412       * getQueuedThreads includes waiting threads       * getQueuedThreads returns all waiting threads
413       */       */
414      public void testGetQueuedThreads() throws InterruptedException {      public void testGetQueuedThreads() {
415          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
416          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
417          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
418          assertTrue(sync.getQueuedThreads().isEmpty());          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
419          sync.acquire(1);          sync.acquire();
420          assertTrue(sync.getQueuedThreads().isEmpty());          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
421          t1.start();          t1.start();
422          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t1);
423            assertHasExclusiveQueuedThreads(sync, t1);
424          assertTrue(sync.getQueuedThreads().contains(t1));          assertTrue(sync.getQueuedThreads().contains(t1));
425            assertFalse(sync.getQueuedThreads().contains(t2));
426          t2.start();          t2.start();
427          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t2);
428            assertHasExclusiveQueuedThreads(sync, t1, t2);
429          assertTrue(sync.getQueuedThreads().contains(t1));          assertTrue(sync.getQueuedThreads().contains(t1));
430          assertTrue(sync.getQueuedThreads().contains(t2));          assertTrue(sync.getQueuedThreads().contains(t2));
431          t1.interrupt();          t1.interrupt();
432          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t1);
433          assertFalse(sync.getQueuedThreads().contains(t1));          assertHasExclusiveQueuedThreads(sync, t2);
434          assertTrue(sync.getQueuedThreads().contains(t2));          sync.release();
435          sync.release(1);          awaitTermination(t2);
436          Thread.sleep(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
         assertTrue(sync.getQueuedThreads().isEmpty());  
         t1.join();  
         t2.join();  
437      }      }
438    
439      /**      /**
440       * getExclusiveQueuedThreads includes waiting threads       * getExclusiveQueuedThreads returns all exclusive waiting threads
441       */       */
442      public void testGetExclusiveQueuedThreads() throws InterruptedException {      public void testGetExclusiveQueuedThreads() {
443          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
444          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
445          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
446          assertTrue(sync.getExclusiveQueuedThreads().isEmpty());          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
447          sync.acquire(1);          sync.acquire();
448          assertTrue(sync.getExclusiveQueuedThreads().isEmpty());          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
449          t1.start();          t1.start();
450          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t1);
451            assertHasExclusiveQueuedThreads(sync, t1);
452          assertTrue(sync.getExclusiveQueuedThreads().contains(t1));          assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
453            assertFalse(sync.getExclusiveQueuedThreads().contains(t2));
454          t2.start();          t2.start();
455          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t2);
456            assertHasExclusiveQueuedThreads(sync, t1, t2);
457          assertTrue(sync.getExclusiveQueuedThreads().contains(t1));          assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
458          assertTrue(sync.getExclusiveQueuedThreads().contains(t2));          assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
459          t1.interrupt();          t1.interrupt();
460          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t1);
461          assertFalse(sync.getExclusiveQueuedThreads().contains(t1));          assertHasExclusiveQueuedThreads(sync, t2);
462          assertTrue(sync.getExclusiveQueuedThreads().contains(t2));          sync.release();
463          sync.release(1);          awaitTermination(t2);
464          Thread.sleep(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
         assertTrue(sync.getExclusiveQueuedThreads().isEmpty());  
         t1.join();  
         t2.join();  
465      }      }
466    
467      /**      /**
468       * getSharedQueuedThreads does not include exclusively waiting threads       * getSharedQueuedThreads does not include exclusively waiting threads
469       */       */
470      public void testGetSharedQueuedThreads() throws InterruptedException {      public void testGetSharedQueuedThreads_Exclusive() {
471          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
         Thread t1 = new Thread(new InterruptedSyncRunnable(sync));  
         Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));  
472          assertTrue(sync.getSharedQueuedThreads().isEmpty());          assertTrue(sync.getSharedQueuedThreads().isEmpty());
473          sync.acquire(1);          sync.acquire();
474          assertTrue(sync.getSharedQueuedThreads().isEmpty());          assertTrue(sync.getSharedQueuedThreads().isEmpty());
475          t1.start();          Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync));
476          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t1);
477          assertTrue(sync.getSharedQueuedThreads().isEmpty());          assertTrue(sync.getSharedQueuedThreads().isEmpty());
478          t2.start();          Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync));
479          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t2);
480          assertTrue(sync.getSharedQueuedThreads().isEmpty());          assertTrue(sync.getSharedQueuedThreads().isEmpty());
481          t1.interrupt();          t1.interrupt();
482          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t1);
483          assertTrue(sync.getSharedQueuedThreads().isEmpty());          assertTrue(sync.getSharedQueuedThreads().isEmpty());
484          sync.release(1);          sync.release();
485          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t2);
486          assertTrue(sync.getSharedQueuedThreads().isEmpty());          assertTrue(sync.getSharedQueuedThreads().isEmpty());
         t1.join();  
         t2.join();  
487      }      }
488    
489      /**      /**
490       * tryAcquireNanos is interruptible.       * getSharedQueuedThreads returns all shared waiting threads
491       */       */
492      public void testInterruptedException2() throws InterruptedException {      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();          final Mutex sync = new Mutex();
520          sync.acquire(1);          sync.acquire();
521          Thread t = new Thread(new CheckedInterruptedRunnable() {          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
522              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
523                  sync.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000L * 1000L);                  sync.tryAcquireNanos(MILLISECONDS.toNanos(2 * LONG_DELAY_MS));
524              }});              }});
525    
526          t.start();          waitForQueuedThread(sync, t);
         Thread.sleep(SHORT_DELAY_MS);  
527          t.interrupt();          t.interrupt();
528          t.join();          awaitTermination(t);
529      }      }
530    
   
531      /**      /**
532       * TryAcquire on exclusively held sync fails       * tryAcquire on exclusively held sync fails
533       */       */
534      public void testTryAcquireWhenSynced() throws InterruptedException {      public void testTryAcquireWhenSynced() {
535          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
536          sync.acquire(1);          sync.acquire();
537          Thread t = new Thread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
538              public void realRun() {              public void realRun() {
539                  threadAssertFalse(sync.tryAcquire(1));                  assertFalse(sync.tryAcquire());
540              }});              }});
541    
542          t.start();          awaitTermination(t);
543          t.join();          sync.release();
         sync.release(1);  
544      }      }
545    
546      /**      /**
547       * tryAcquireNanos on an exclusively held sync times out       * tryAcquireNanos on an exclusively held sync times out
548       */       */
549      public void testAcquireNanos_Timeout() throws InterruptedException {      public void testAcquireNanos_Timeout() {
550          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
551          sync.acquire(1);          sync.acquire();
552          Thread t = new Thread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
553              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
554                  threadAssertFalse(sync.tryAcquireNanos(1, SHORT_DELAY_MS * 1000L * 1000L));                  long startTime = System.nanoTime();
555                    long nanos = MILLISECONDS.toNanos(timeoutMillis());
556                    assertFalse(sync.tryAcquireNanos(nanos));
557                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
558              }});              }});
559    
560          t.start();          awaitTermination(t);
561          t.join();          sync.release();
         sync.release(1);  
562      }      }
563    
   
564      /**      /**
565       * getState is true when acquired and false when not       * getState is true when acquired and false when not
566       */       */
567      public void testGetState() throws InterruptedException {      public void testGetState() {
568          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
569          sync.acquire(1);          sync.acquire();
570          assertTrue(sync.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
571          sync.release(1);          sync.release();
572          assertFalse(sync.isHeldExclusively());          assertFalse(sync.isHeldExclusively());
573          Thread t = new Thread(new CheckedRunnable() {  
574            final BooleanLatch acquired = new BooleanLatch();
575            final BooleanLatch done = new BooleanLatch();
576            Thread t = newStartedThread(new CheckedRunnable() {
577              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
578                  sync.acquire(1);                  sync.acquire();
579                  Thread.sleep(SMALL_DELAY_MS);                  assertTrue(acquired.releaseShared(0));
580                  sync.release(1);                  done.acquireShared(0);
581                    sync.release();
582              }});              }});
583    
584          t.start();          acquired.acquireShared(0);
         Thread.sleep(SHORT_DELAY_MS);  
585          assertTrue(sync.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
586          t.join();          assertTrue(done.releaseShared(0));
587            awaitTermination(t);
588          assertFalse(sync.isHeldExclusively());          assertFalse(sync.isHeldExclusively());
589      }      }
590    
   
     /**  
      * acquireInterruptibly is interruptible.  
      */  
     public void testAcquireInterruptibly1() throws InterruptedException {  
         final Mutex sync = new Mutex();  
         sync.acquire(1);  
         Thread t = new Thread(new InterruptedSyncRunnable(sync));  
   
         t.start();  
         Thread.sleep(SHORT_DELAY_MS);  
         t.interrupt();  
         Thread.sleep(SHORT_DELAY_MS);  
         sync.release(1);  
         t.join();  
     }  
   
591      /**      /**
592       * acquireInterruptibly succeeds when released, else is interruptible       * acquireInterruptibly succeeds when released, else is interruptible
593       */       */
594      public void testAcquireInterruptibly2() throws InterruptedException {      public void testAcquireInterruptibly() throws InterruptedException {
595          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
596          sync.acquireInterruptibly(1);          final BooleanLatch threadStarted = new BooleanLatch();
597          Thread t = new Thread(new InterruptedSyncRunnable(sync));          sync.acquireInterruptibly();
598          t.start();          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
599          Thread.sleep(SHORT_DELAY_MS);              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();          t.interrupt();
607            awaitTermination(t);
608          assertTrue(sync.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
         t.join();  
609      }      }
610    
611      /**      /**
# Line 429  Line 613 
613       */       */
614      public void testOwns() {      public void testOwns() {
615          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
616          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
617          final Mutex sync2 = new Mutex();          final Mutex sync2 = new Mutex();
618          assertTrue(sync.owns(c));          assertTrue(sync.owns(c));
619          assertFalse(sync2.owns(c));          assertFalse(sync2.owns(c));
# Line 438  Line 622 
622      /**      /**
623       * Calling await without holding sync throws IllegalMonitorStateException       * Calling await without holding sync throws IllegalMonitorStateException
624       */       */
625      public void testAwait_IllegalMonitor() throws InterruptedException {      public void testAwait_IMSE() {
626          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
627          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
628            for (AwaitMethod awaitMethod : AwaitMethod.values()) {
629                long startTime = System.nanoTime();
630          try {          try {
631              c.await();                  await(c, awaitMethod);
632              shouldThrow();              shouldThrow();
633          } catch (IllegalMonitorStateException success) {}              } 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       * Calling signal without holding sync throws IllegalMonitorStateException
641       */       */
642      public void testSignal_IllegalMonitor() {      public void testSignal_IMSE() {
643          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
644          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
645          try {          try {
646              c.signal();              c.signal();
647              shouldThrow();              shouldThrow();
648          } catch (IllegalMonitorStateException success) {}          } catch (IllegalMonitorStateException success) {}
649            assertHasWaitersUnlocked(sync, c, NO_THREADS);
650      }      }
651    
652      /**      /**
653       * awaitNanos without a signal times out       * Calling signalAll without holding sync throws IllegalMonitorStateException
654       */       */
655      public void testAwaitNanos_Timeout() throws InterruptedException {      public void testSignalAll_IMSE() {
656          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
657          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
658          sync.acquire(1);          try {
659          long t = c.awaitNanos(100);              c.signalAll();
660          assertTrue(t <= 0);              shouldThrow();
661          sync.release(1);          } catch (IllegalMonitorStateException success) {}
     }  
   
     /**  
      *  Timed await without a signal times out  
      */  
     public void testAwait_Timeout() throws InterruptedException {  
         final Mutex sync = new Mutex();  
         final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();  
         sync.acquire(1);  
         assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS));  
         sync.release(1);  
662      }      }
663    
664      /**      /**
665       * awaitUntil without a signal times out       * await/awaitNanos/awaitUntil without a signal times out
666       */       */
667      public void testAwaitUntil_Timeout() throws InterruptedException {      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();          final Mutex sync = new Mutex();
672          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
673          sync.acquire(1);          sync.acquire();
674          java.util.Date d = new java.util.Date();          assertAwaitTimesOut(c, awaitMethod);
675          assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));          sync.release();
         sync.release(1);  
676      }      }
677    
678      /**      /**
679       * await returns when signalled       * await/awaitNanos/awaitUntil returns when signalled
680       */       */
681      public void testAwait() throws InterruptedException {      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();          final Mutex sync = new Mutex();
687          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
688          Thread t = new Thread(new CheckedRunnable() {          final BooleanLatch acquired = new BooleanLatch();
689            Thread t = newStartedThread(new CheckedRunnable() {
690              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
691                  sync.acquire(1);                  sync.acquire();
692                  c.await();                  assertTrue(acquired.releaseShared(0));
693                  sync.release(1);                  await(c, awaitMethod);
694                    sync.release();
695              }});              }});
696    
697          t.start();          acquired.acquireShared(0);
698          Thread.sleep(SHORT_DELAY_MS);          sync.acquire();
699          sync.acquire(1);          assertHasWaitersLocked(sync, c, t);
700            assertHasExclusiveQueuedThreads(sync, NO_THREADS);
701          c.signal();          c.signal();
702          sync.release(1);          assertHasWaitersLocked(sync, c, NO_THREADS);
703          t.join(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, t);
704          assertFalse(t.isAlive());          sync.release();
705            awaitTermination(t);
706      }      }
707    
   
   
708      /**      /**
709       * hasWaiters throws NPE if null       * hasWaiters(null) throws NullPointerException
710       */       */
711      public void testHasWaitersNPE() {      public void testHasWaitersNPE() {
712          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
# Line 530  Line 717 
717      }      }
718    
719      /**      /**
720       * getWaitQueueLength throws NPE if null       * getWaitQueueLength(null) throws NullPointerException
721       */       */
722      public void testGetWaitQueueLengthNPE() {      public void testGetWaitQueueLengthNPE() {
723          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
# Line 540  Line 727 
727          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
728      }      }
729    
   
730      /**      /**
731       * getWaitingThreads throws NPE if null       * getWaitingThreads(null) throws NullPointerException
732       */       */
733      public void testGetWaitingThreadsNPE() {      public void testGetWaitingThreadsNPE() {
734          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
# Line 552  Line 738 
738          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
739      }      }
740    
   
741      /**      /**
742       * hasWaiters throws IAE if not owned       * hasWaiters throws IllegalArgumentException if not owned
743       */       */
744      public void testHasWaitersIAE() {      public void testHasWaitersIAE() {
745          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
746          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
747          final Mutex sync2 = new Mutex();          final Mutex sync2 = new Mutex();
748          try {          try {
749              sync2.hasWaiters(c);              sync2.hasWaiters(c);
750              shouldThrow();              shouldThrow();
751          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
752            assertHasWaitersUnlocked(sync, c, NO_THREADS);
753      }      }
754    
755      /**      /**
756       * hasWaiters throws IMSE if not synced       * hasWaiters throws IllegalMonitorStateException if not synced
757       */       */
758      public void testHasWaitersIMSE() {      public void testHasWaitersIMSE() {
759          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
760          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
761          try {          try {
762              sync.hasWaiters(c);              sync.hasWaiters(c);
763              shouldThrow();              shouldThrow();
764          } catch (IllegalMonitorStateException success) {}          } catch (IllegalMonitorStateException success) {}
765            assertHasWaitersUnlocked(sync, c, NO_THREADS);
766      }      }
767    
   
768      /**      /**
769       * getWaitQueueLength throws IAE if not owned       * getWaitQueueLength throws IllegalArgumentException if not owned
770       */       */
771      public void testGetWaitQueueLengthIAE() {      public void testGetWaitQueueLengthIAE() {
772          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
773          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
774          final Mutex sync2 = new Mutex();          final Mutex sync2 = new Mutex();
775          try {          try {
776              sync2.getWaitQueueLength(c);              sync2.getWaitQueueLength(c);
777              shouldThrow();              shouldThrow();
778          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
779            assertHasWaitersUnlocked(sync, c, NO_THREADS);
780      }      }
781    
782      /**      /**
783       * getWaitQueueLength throws IMSE if not synced       * getWaitQueueLength throws IllegalMonitorStateException if not synced
784       */       */
785      public void testGetWaitQueueLengthIMSE() {      public void testGetWaitQueueLengthIMSE() {
786          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
787          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
788          try {          try {
789              sync.getWaitQueueLength(c);              sync.getWaitQueueLength(c);
790              shouldThrow();              shouldThrow();
791          } catch (IllegalMonitorStateException success) {}          } catch (IllegalMonitorStateException success) {}
792            assertHasWaitersUnlocked(sync, c, NO_THREADS);
793      }      }
794    
   
795      /**      /**
796       * getWaitingThreads throws IAE if not owned       * getWaitingThreads throws IllegalArgumentException if not owned
797       */       */
798      public void testGetWaitingThreadsIAE() {      public void testGetWaitingThreadsIAE() {
799          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
800          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
801          final Mutex sync2 = new Mutex();          final Mutex sync2 = new Mutex();
802          try {          try {
803              sync2.getWaitingThreads(c);              sync2.getWaitingThreads(c);
804              shouldThrow();              shouldThrow();
805          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
806            assertHasWaitersUnlocked(sync, c, NO_THREADS);
807      }      }
808    
809      /**      /**
810       * getWaitingThreads throws IMSE if not synced       * getWaitingThreads throws IllegalMonitorStateException if not synced
811       */       */
812      public void testGetWaitingThreadsIMSE() {      public void testGetWaitingThreadsIMSE() {
813          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
814          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
815          try {          try {
816              sync.getWaitingThreads(c);              sync.getWaitingThreads(c);
817              shouldThrow();              shouldThrow();
818          } catch (IllegalMonitorStateException success) {}          } catch (IllegalMonitorStateException success) {}
819            assertHasWaitersUnlocked(sync, c, NO_THREADS);
820      }      }
821    
   
   
822      /**      /**
823       * hasWaiters returns true when a thread is waiting, else false       * hasWaiters returns true when a thread is waiting, else false
824       */       */
825      public void testHasWaiters() throws InterruptedException {      public void testHasWaiters() {
826          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
827          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
828          Thread t = new Thread(new CheckedRunnable() {          final BooleanLatch acquired = new BooleanLatch();
829            Thread t = newStartedThread(new CheckedRunnable() {
830              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
831                  sync.acquire(1);                  sync.acquire();
832                  threadAssertFalse(sync.hasWaiters(c));                  assertHasWaitersLocked(sync, c, NO_THREADS);
833                  threadAssertEquals(0, sync.getWaitQueueLength(c));                  assertFalse(sync.hasWaiters(c));
834                    assertTrue(acquired.releaseShared(0));
835                  c.await();                  c.await();
836                  sync.release(1);                  sync.release();
837              }});              }});
838    
839          t.start();          acquired.acquireShared(0);
840          Thread.sleep(SHORT_DELAY_MS);          sync.acquire();
841          sync.acquire(1);          assertHasWaitersLocked(sync, c, t);
842            assertHasExclusiveQueuedThreads(sync, NO_THREADS);
843          assertTrue(sync.hasWaiters(c));          assertTrue(sync.hasWaiters(c));
         assertEquals(1, sync.getWaitQueueLength(c));  
844          c.signal();          c.signal();
845          sync.release(1);          assertHasWaitersLocked(sync, c, NO_THREADS);
846          Thread.sleep(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, t);
         sync.acquire(1);  
847          assertFalse(sync.hasWaiters(c));          assertFalse(sync.hasWaiters(c));
848          assertEquals(0, sync.getWaitQueueLength(c));          sync.release();
849          sync.release(1);  
850          t.join(SHORT_DELAY_MS);          awaitTermination(t);
851          assertFalse(t.isAlive());          assertHasWaitersUnlocked(sync, c, NO_THREADS);
852      }      }
853    
854      /**      /**
855       * getWaitQueueLength returns number of waiting threads       * getWaitQueueLength returns number of waiting threads
856       */       */
857      public void testGetWaitQueueLength() throws InterruptedException {      public void testGetWaitQueueLength() {
858          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
859          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
860          Thread t1 = new Thread(new CheckedRunnable() {          final BooleanLatch acquired1 = new BooleanLatch();
861            final BooleanLatch acquired2 = new BooleanLatch();
862            final Thread t1 = newStartedThread(new CheckedRunnable() {
863              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
864                  sync.acquire(1);                  sync.acquire();
865                  threadAssertFalse(sync.hasWaiters(c));                  assertHasWaitersLocked(sync, c, NO_THREADS);
866                  threadAssertEquals(0, sync.getWaitQueueLength(c));                  assertEquals(0, sync.getWaitQueueLength(c));
867                    assertTrue(acquired1.releaseShared(0));
868                  c.await();                  c.await();
869                  sync.release(1);                  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          Thread t2 = new Thread(new CheckedRunnable() {          final Thread t2 = newStartedThread(new CheckedRunnable() {
878              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
879                  sync.acquire(1);                  sync.acquire();
880                  threadAssertTrue(sync.hasWaiters(c));                  assertHasWaitersLocked(sync, c, t1);
881                  threadAssertEquals(1, sync.getWaitQueueLength(c));                  assertEquals(1, sync.getWaitQueueLength(c));
882                    assertTrue(acquired2.releaseShared(0));
883                  c.await();                  c.await();
884                  sync.release(1);                  sync.release();
885              }});              }});
886            acquired2.acquireShared(0);
887          t1.start();          sync.acquire();
888          Thread.sleep(SHORT_DELAY_MS);          assertHasWaitersLocked(sync, c, t1, t2);
889          t2.start();          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
         Thread.sleep(SHORT_DELAY_MS);  
         sync.acquire(1);  
         assertTrue(sync.hasWaiters(c));  
890          assertEquals(2, sync.getWaitQueueLength(c));          assertEquals(2, sync.getWaitQueueLength(c));
891          c.signalAll();          c.signalAll();
892          sync.release(1);          assertHasWaitersLocked(sync, c, NO_THREADS);
893          Thread.sleep(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, t1, t2);
         sync.acquire(1);  
         assertFalse(sync.hasWaiters(c));  
894          assertEquals(0, sync.getWaitQueueLength(c));          assertEquals(0, sync.getWaitQueueLength(c));
895          sync.release(1);          sync.release();
896          t1.join(SHORT_DELAY_MS);  
897          t2.join(SHORT_DELAY_MS);          awaitTermination(t1);
898          assertFalse(t1.isAlive());          awaitTermination(t2);
899          assertFalse(t2.isAlive());          assertHasWaitersUnlocked(sync, c, NO_THREADS);
900      }      }
901    
902      /**      /**
903       * getWaitingThreads returns only and all waiting threads       * getWaitingThreads returns only and all waiting threads
904       */       */
905      public void testGetWaitingThreads() throws InterruptedException {      public void testGetWaitingThreads() {
906          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
907          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
908          Thread t1 = new Thread(new CheckedRunnable() {          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 {              public void realRun() throws InterruptedException {
912                  sync.acquire(1);                  sync.acquire();
913                  threadAssertTrue(sync.getWaitingThreads(c).isEmpty());                  assertHasWaitersLocked(sync, c, NO_THREADS);
914                    assertTrue(sync.getWaitingThreads(c).isEmpty());
915                    assertTrue(acquired1.releaseShared(0));
916                  c.await();                  c.await();
917                  sync.release(1);                  sync.release();
918              }});              }});
919    
920          Thread t2 = new Thread(new CheckedRunnable() {          final Thread t2 = new Thread(new CheckedRunnable() {
921              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
922                  sync.acquire(1);                  sync.acquire();
923                  threadAssertFalse(sync.getWaitingThreads(c).isEmpty());                  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();                  c.await();
929                  sync.release(1);                  sync.release();
930              }});              }});
931    
932          sync.acquire(1);          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());          assertTrue(sync.getWaitingThreads(c).isEmpty());
937          sync.release(1);          assertEquals(0, sync.getWaitingThreads(c).size());
938            sync.release();
939    
940          t1.start();          t1.start();
941          Thread.sleep(SHORT_DELAY_MS);          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();          t2.start();
951          Thread.sleep(SHORT_DELAY_MS);          acquired2.acquireShared(0);
952          sync.acquire(1);          sync.acquire();
953          assertTrue(sync.hasWaiters(c));          assertHasWaitersLocked(sync, c, t1, t2);
954            assertHasExclusiveQueuedThreads(sync, NO_THREADS);
955          assertTrue(sync.getWaitingThreads(c).contains(t1));          assertTrue(sync.getWaitingThreads(c).contains(t1));
956          assertTrue(sync.getWaitingThreads(c).contains(t2));          assertTrue(sync.getWaitingThreads(c).contains(t2));
957            assertFalse(sync.getWaitingThreads(c).isEmpty());
958            assertEquals(2, sync.getWaitingThreads(c).size());
959          c.signalAll();          c.signalAll();
960          sync.release(1);          assertHasWaitersLocked(sync, c, NO_THREADS);
961          Thread.sleep(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, t1, t2);
962          sync.acquire(1);          assertFalse(sync.getWaitingThreads(c).contains(t1));
963          assertFalse(sync.hasWaiters(c));          assertFalse(sync.getWaitingThreads(c).contains(t2));
964          assertTrue(sync.getWaitingThreads(c).isEmpty());          assertTrue(sync.getWaitingThreads(c).isEmpty());
965          sync.release(1);          assertEquals(0, sync.getWaitingThreads(c).size());
966          t1.join(SHORT_DELAY_MS);          sync.release();
         t2.join(SHORT_DELAY_MS);  
         assertFalse(t1.isAlive());  
         assertFalse(t2.isAlive());  
     }  
967    
968            awaitTermination(t1);
969            awaitTermination(t2);
970      /**          assertHasWaitersUnlocked(sync, c, NO_THREADS);
      * awaitUninterruptibly doesn't abort on interrupt  
      */  
     public void testAwaitUninterruptibly() throws InterruptedException {  
         final Mutex sync = new Mutex();  
         final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();  
         Thread t = new Thread(new CheckedRunnable() {  
             public void realRun() {  
                 sync.acquire(1);  
                 c.awaitUninterruptibly();  
                 sync.release(1);  
             }});  
   
         t.start();  
         Thread.sleep(SHORT_DELAY_MS);  
         t.interrupt();  
         sync.acquire(1);  
         c.signal();  
         sync.release(1);  
         t.join(SHORT_DELAY_MS);  
         assertFalse(t.isAlive());  
971      }      }
972    
973      /**      /**
974       * await is interruptible       * awaitUninterruptibly is uninterruptible
975       */       */
976      public void testAwait_Interrupt() throws InterruptedException {      public void testAwaitUninterruptibly() {
977          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
978          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject condition = sync.newCondition();
979          Thread t = new Thread(new CheckedInterruptedRunnable() {          final BooleanLatch pleaseInterrupt = new BooleanLatch();
980              public void realRun() throws InterruptedException {          Thread t = newStartedThread(new CheckedRunnable() {
981                  sync.acquire(1);              public void realRun() {
982                  c.await();                  sync.acquire();
983              }});                  assertTrue(pleaseInterrupt.releaseShared(0));
984                    condition.awaitUninterruptibly();
985          t.start();                  assertTrue(Thread.interrupted());
986          Thread.sleep(SHORT_DELAY_MS);                  assertHasWaitersLocked(sync, condition, NO_THREADS);
987          t.interrupt();                  sync.release();
         t.join(SHORT_DELAY_MS);  
         assertFalse(t.isAlive());  
     }  
   
     /**  
      * awaitNanos is interruptible  
      */  
     public void testAwaitNanos_Interrupt() throws InterruptedException {  
         final Mutex sync = new Mutex();  
         final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();  
         Thread t = new Thread(new CheckedInterruptedRunnable() {  
             public void realRun() throws InterruptedException {  
                 sync.acquire(1);  
                 c.awaitNanos(LONG_DELAY_MS * 1000L * 1000L);  
988              }});              }});
989    
990          t.start();          pleaseInterrupt.acquireShared(0);
991          Thread.sleep(SHORT_DELAY_MS);          sync.acquire();
992            assertHasWaitersLocked(sync, condition, t);
993            sync.release();
994          t.interrupt();          t.interrupt();
995          t.join(SHORT_DELAY_MS);          assertHasWaitersUnlocked(sync, condition, t);
996          assertFalse(t.isAlive());          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       * awaitUntil is interruptible       * await/awaitNanos/awaitUntil is interruptible
1009       */       */
1010      public void testAwaitUntil_Interrupt() throws InterruptedException {      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();          final Mutex sync = new Mutex();
1016          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
1017          Thread t = new Thread(new CheckedInterruptedRunnable() {          final BooleanLatch pleaseInterrupt = new BooleanLatch();
1018            Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1019              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
1020                  sync.acquire(1);                  sync.acquire();
1021                  java.util.Date d = new java.util.Date();                  assertTrue(pleaseInterrupt.releaseShared(0));
1022                  c.awaitUntil(new java.util.Date(d.getTime() + 10000));                  await(c, awaitMethod);
1023              }});              }});
1024    
1025          t.start();          pleaseInterrupt.acquireShared(0);
         Thread.sleep(SHORT_DELAY_MS);  
1026          t.interrupt();          t.interrupt();
1027          t.join(SHORT_DELAY_MS);          awaitTermination(t);
         assertFalse(t.isAlive());  
1028      }      }
1029    
1030      /**      /**
1031       * signalAll wakes up all threads       * signalAll wakes up all threads
1032       */       */
1033      public void testSignalAll() throws InterruptedException {      public void testSignalAll_await()      { testSignalAll(AwaitMethod.await); }
1034          final Mutex sync = new Mutex();      public void testSignalAll_awaitTimed() { testSignalAll(AwaitMethod.awaitTimed); }
1035          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();      public void testSignalAll_awaitNanos() { testSignalAll(AwaitMethod.awaitNanos); }
1036          Thread t1 = new Thread(new CheckedRunnable() {      public void testSignalAll_awaitUntil() { testSignalAll(AwaitMethod.awaitUntil); }
1037              public void realRun() throws InterruptedException {      public void testSignalAll(final AwaitMethod awaitMethod) {
1038                  sync.acquire(1);          final Mutex sync = new Mutex();
1039                  c.await();          final ConditionObject c = sync.newCondition();
1040                  sync.release(1);          final BooleanLatch acquired1 = new BooleanLatch();
1041              }});          final BooleanLatch acquired2 = new BooleanLatch();
1042            Thread t1 = newStartedThread(new CheckedRunnable() {
1043          Thread t2 = new Thread(new CheckedRunnable() {              public void realRun() throws InterruptedException {
1044              public void realRun() throws InterruptedException {                  sync.acquire();
1045                  sync.acquire(1);                  acquired1.releaseShared(0);
1046                  c.await();                  await(c, awaitMethod);
1047                  sync.release(1);                  sync.release();
1048              }});              }});
1049    
1050          t1.start();          Thread t2 = newStartedThread(new CheckedRunnable() {
1051          t2.start();              public void realRun() throws InterruptedException {
1052          Thread.sleep(SHORT_DELAY_MS);                  sync.acquire();
1053          sync.acquire(1);                  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();          c.signalAll();
1064          sync.release(1);          assertHasWaitersLocked(sync, c, NO_THREADS);
1065          t1.join(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, t1, t2);
1066          t2.join(SHORT_DELAY_MS);          sync.release();
1067          assertFalse(t1.isAlive());          awaitTermination(t1);
1068          assertFalse(t2.isAlive());          awaitTermination(t2);
1069      }      }
1070    
   
1071      /**      /**
1072       * toString indicates current state       * toString indicates current state
1073       */       */
1074      public void testToString() {      public void testToString() {
1075          Mutex sync = new Mutex();          Mutex sync = new Mutex();
1076          String us = sync.toString();          assertTrue(sync.toString().contains("State = " + Mutex.UNLOCKED));
1077          assertTrue(us.indexOf("State = 0") >= 0);          sync.acquire();
1078          sync.acquire(1);          assertTrue(sync.toString().contains("State = " + Mutex.LOCKED));
         String ls = sync.toString();  
         assertTrue(ls.indexOf("State = 1") >= 0);  
1079      }      }
1080    
1081      /**      /**
1082       * A serialized AQS deserializes with current state       * A serialized AQS deserializes with current state, but no queued threads
1083       */       */
1084      public void testSerialization() throws Exception {      public void testSerialization() {
1085          Mutex l = new Mutex();          Mutex sync = new Mutex();
1086          l.acquire(1);          assertFalse(serialClone(sync).isHeldExclusively());
1087          assertTrue(l.isHeldExclusively());          sync.acquire();
1088            Thread t = newStartedThread(new InterruptedSyncRunnable(sync));
1089          ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);          waitForQueuedThread(sync, t);
1090          ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));          assertTrue(sync.isHeldExclusively());
         out.writeObject(l);  
         out.close();  
   
         ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());  
         ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));  
         Mutex r = (Mutex) in.readObject();  
         assertTrue(r.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       * tryReleaseShared setting state changes getState
# Line 907  Line 1108 
1108      public void testGetStateWithReleaseShared() {      public void testGetStateWithReleaseShared() {
1109          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1110          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1111          l.releaseShared(0);          assertTrue(l.releaseShared(0));
1112          assertTrue(l.isSignalled());          assertTrue(l.isSignalled());
1113      }      }
1114    
# Line 917  Line 1118 
1118      public void testReleaseShared() {      public void testReleaseShared() {
1119          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1120          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1121          l.releaseShared(0);          assertTrue(l.releaseShared(0));
1122          assertTrue(l.isSignalled());          assertTrue(l.isSignalled());
1123          l.releaseShared(0);          assertTrue(l.releaseShared(0));
1124          assertTrue(l.isSignalled());          assertTrue(l.isSignalled());
1125      }      }
1126    
1127      /**      /**
1128       * acquireSharedInterruptibly returns after release, but not before       * acquireSharedInterruptibly returns after release, but not before
1129       */       */
1130      public void testAcquireSharedInterruptibly() throws InterruptedException {      public void testAcquireSharedInterruptibly() {
1131          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1132    
1133          Thread t = new Thread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
1134              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
1135                  threadAssertFalse(l.isSignalled());                  assertFalse(l.isSignalled());
1136                    l.acquireSharedInterruptibly(0);
1137                    assertTrue(l.isSignalled());
1138                  l.acquireSharedInterruptibly(0);                  l.acquireSharedInterruptibly(0);
1139                  threadAssertTrue(l.isSignalled());                  assertTrue(l.isSignalled());
1140              }});              }});
1141    
1142          t.start();          waitForQueuedThread(l, t);
1143          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1144          Thread.sleep(SHORT_DELAY_MS);          assertThreadBlocks(t, Thread.State.WAITING);
1145          l.releaseShared(0);          assertHasSharedQueuedThreads(l, t);
1146            assertTrue(l.releaseShared(0));
1147          assertTrue(l.isSignalled());          assertTrue(l.isSignalled());
1148          t.join();          awaitTermination(t);
1149      }      }
1150    
   
1151      /**      /**
1152       * acquireSharedTimed returns after release       * tryAcquireSharedNanos returns after release, but not before
1153       */       */
1154      public void testAsquireSharedTimed() throws InterruptedException {      public void testTryAcquireSharedNanos() {
1155          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1156    
1157          Thread t = new Thread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
1158              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
1159                  threadAssertFalse(l.isSignalled());                  assertFalse(l.isSignalled());
1160                  threadAssertTrue(l.tryAcquireSharedNanos(0, MEDIUM_DELAY_MS * 1000L * 1000L));                  long nanos = MILLISECONDS.toNanos(2 * LONG_DELAY_MS);
1161                  threadAssertTrue(l.isSignalled());                  assertTrue(l.tryAcquireSharedNanos(0, nanos));
1162                    assertTrue(l.isSignalled());
1163                    assertTrue(l.tryAcquireSharedNanos(0, nanos));
1164                    assertTrue(l.isSignalled());
1165              }});              }});
1166    
1167          t.start();          waitForQueuedThread(l, t);
1168          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1169          Thread.sleep(SHORT_DELAY_MS);          assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1170          l.releaseShared(0);          assertTrue(l.releaseShared(0));
1171          assertTrue(l.isSignalled());          assertTrue(l.isSignalled());
1172          t.join();          awaitTermination(t);
1173      }      }
1174    
1175      /**      /**
1176       * acquireSharedInterruptibly throws IE if interrupted before released       * acquireSharedInterruptibly is interruptible
1177       */       */
1178      public void testAcquireSharedInterruptibly_InterruptedException() throws InterruptedException {      public void testAcquireSharedInterruptibly_Interruptible() {
1179          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1180          Thread t = new Thread(new CheckedInterruptedRunnable() {          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1181              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
1182                  threadAssertFalse(l.isSignalled());                  assertFalse(l.isSignalled());
1183                  l.acquireSharedInterruptibly(0);                  l.acquireSharedInterruptibly(0);
1184              }});              }});
1185    
1186          t.start();          waitForQueuedThread(l, t);
1187          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1188          t.interrupt();          t.interrupt();
1189          t.join();          awaitTermination(t);
1190            assertFalse(l.isSignalled());
1191      }      }
1192    
1193      /**      /**
1194       * acquireSharedTimed throws IE if interrupted before released       * tryAcquireSharedNanos is interruptible
1195       */       */
1196      public void testAcquireSharedNanos_InterruptedException() throws InterruptedException {      public void testTryAcquireSharedNanos_Interruptible() {
1197          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1198          Thread t = new Thread(new CheckedInterruptedRunnable() {          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1199              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
1200                  threadAssertFalse(l.isSignalled());                  assertFalse(l.isSignalled());
1201                  l.tryAcquireSharedNanos(0, SMALL_DELAY_MS * 1000L * 1000L);                  long nanos = MILLISECONDS.toNanos(2 * LONG_DELAY_MS);
1202                    l.tryAcquireSharedNanos(0, nanos);
1203              }});              }});
1204    
1205          t.start();          waitForQueuedThread(l, t);
         Thread.sleep(SHORT_DELAY_MS);  
1206          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1207          t.interrupt();          t.interrupt();
1208          t.join();          awaitTermination(t);
1209            assertFalse(l.isSignalled());
1210      }      }
1211    
1212      /**      /**
1213       * acquireSharedTimed times out if not released before timeout       * tryAcquireSharedNanos times out if not released before timeout
1214       */       */
1215      public void testAcquireSharedNanos_Timeout() throws InterruptedException {      public void testTryAcquireSharedNanos_Timeout() {
1216          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1217          Thread t = new Thread(new CheckedRunnable() {          final BooleanLatch observedQueued = new BooleanLatch();
1218            Thread t = newStartedThread(new CheckedRunnable() {
1219              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
1220                  threadAssertFalse(l.isSignalled());                  assertFalse(l.isSignalled());
1221                  threadAssertFalse(l.tryAcquireSharedNanos(0, SMALL_DELAY_MS * 1000L * 1000L));                  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          t.start();          waitForQueuedThread(l, t);
1233          Thread.sleep(SHORT_DELAY_MS);          observedQueued.releaseShared(0);
1234            assertFalse(l.isSignalled());
1235            awaitTermination(t);
1236          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1237          t.join();      }
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  }  }

Legend:
Removed from v.1.32  
changed lines
  Added in v.1.63

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8