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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8