[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.31, Sat Nov 21 17:54:04 2009 UTC revision 1.52, Fri Jul 3 05:48:30 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;
243            try {
244                switch (awaitMethod) {
245                case awaitTimed:
246                    startTime = System.nanoTime();
247                    assertFalse(c.await(timeoutMillis, MILLISECONDS));
248                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
249                    break;
250                case awaitNanos:
251                    startTime = System.nanoTime();
252                    long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
253                    long nanosRemaining = c.awaitNanos(nanosTimeout);
254                    assertTrue(nanosRemaining <= 0);
255                    assertTrue(nanosRemaining > -MILLISECONDS.toNanos(LONG_DELAY_MS));
256                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
257                    break;
258                case awaitUntil:
259                    // We shouldn't assume that nanoTime and currentTimeMillis
260                    // use the same time source, so don't use nanoTime here.
261                    java.util.Date delayedDate = delayedDate(timeoutMillis());
262                    assertFalse(c.awaitUntil(delayedDate(timeoutMillis)));
263                    assertTrue(new java.util.Date().getTime() >= delayedDate.getTime());
264                    break;
265                default:
266                    throw new UnsupportedOperationException();
267          }          }
268            } catch (InterruptedException ie) { threadUnexpectedException(ie); }
269      }      }
270    
271      /**      /**
272       * isHeldExclusively is false upon construction       * isHeldExclusively is false upon construction
273       */       */
274      public void testIsHeldExclusively() {      public void testIsHeldExclusively() {
275          Mutex rl = new Mutex();          Mutex sync = new Mutex();
276          assertFalse(rl.isHeldExclusively());          assertFalse(sync.isHeldExclusively());
277      }      }
278    
279      /**      /**
280       * acquiring released sync succeeds       * acquiring released sync succeeds
281       */       */
282      public void testAcquire() {      public void testAcquire() {
283          Mutex rl = new Mutex();          Mutex sync = new Mutex();
284          rl.acquire(1);          sync.acquire();
285          assertTrue(rl.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
286          rl.release(1);          sync.release();
287          assertFalse(rl.isHeldExclusively());          assertFalse(sync.isHeldExclusively());
288      }      }
289    
290      /**      /**
291       * tryAcquire on an released sync succeeds       * tryAcquire on a released sync succeeds
292       */       */
293      public void testTryAcquire() {      public void testTryAcquire() {
294          Mutex rl = new Mutex();          Mutex sync = new Mutex();
295          assertTrue(rl.tryAcquire(1));          assertTrue(sync.tryAcquire());
296          assertTrue(rl.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
297          rl.release(1);          sync.release();
298            assertFalse(sync.isHeldExclusively());
299      }      }
300    
301      /**      /**
302       * hasQueuedThreads reports whether there are waiting threads       * hasQueuedThreads reports whether there are waiting threads
303       */       */
304      public void testhasQueuedThreads() throws InterruptedException {      public void testHasQueuedThreads() {
305          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
         Thread t1 = new Thread(new InterruptedSyncRunnable(sync));  
         Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));  
306          assertFalse(sync.hasQueuedThreads());          assertFalse(sync.hasQueuedThreads());
307          sync.acquire(1);          sync.acquire();
308          t1.start();          Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync));
309          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t1);
310          assertTrue(sync.hasQueuedThreads());          assertTrue(sync.hasQueuedThreads());
311          t2.start();          Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync));
312          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t2);
313          assertTrue(sync.hasQueuedThreads());          assertTrue(sync.hasQueuedThreads());
314          t1.interrupt();          t1.interrupt();
315          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t1);
316          assertTrue(sync.hasQueuedThreads());          assertTrue(sync.hasQueuedThreads());
317          sync.release(1);          sync.release();
318          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t2);
319          assertFalse(sync.hasQueuedThreads());          assertFalse(sync.hasQueuedThreads());
         t1.join();  
         t2.join();  
320      }      }
321    
322      /**      /**
323       * isQueued(null) throws NPE       * isQueued(null) throws NullPointerException
324       */       */
325      public void testIsQueuedNPE() {      public void testIsQueuedNPE() {
326          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
# Line 156  Line 331 
331      }      }
332    
333      /**      /**
334       * isQueued reports whether a thread is queued.       * isQueued reports whether a thread is queued
335       */       */
336      public void testIsQueued() throws InterruptedException {      public void testIsQueued() {
337          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
338          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
339          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
340          assertFalse(sync.isQueued(t1));          assertFalse(sync.isQueued(t1));
341          assertFalse(sync.isQueued(t2));          assertFalse(sync.isQueued(t2));
342          sync.acquire(1);          sync.acquire();
343          t1.start();          t1.start();
344          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t1);
345          assertTrue(sync.isQueued(t1));          assertTrue(sync.isQueued(t1));
346            assertFalse(sync.isQueued(t2));
347          t2.start();          t2.start();
348          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t2);
349          assertTrue(sync.isQueued(t1));          assertTrue(sync.isQueued(t1));
350          assertTrue(sync.isQueued(t2));          assertTrue(sync.isQueued(t2));
351          t1.interrupt();          t1.interrupt();
352          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t1);
353          assertFalse(sync.isQueued(t1));          assertFalse(sync.isQueued(t1));
354          assertTrue(sync.isQueued(t2));          assertTrue(sync.isQueued(t2));
355          sync.release(1);          sync.release();
356          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t2);
357          assertFalse(sync.isQueued(t1));          assertFalse(sync.isQueued(t1));
         Thread.sleep(SHORT_DELAY_MS);  
358          assertFalse(sync.isQueued(t2));          assertFalse(sync.isQueued(t2));
         t1.join();  
         t2.join();  
359      }      }
360    
361      /**      /**
362       * getFirstQueuedThread returns first waiting thread or null if none       * getFirstQueuedThread returns first waiting thread or null if none
363       */       */
364      public void testGetFirstQueuedThread() throws InterruptedException {      public void testGetFirstQueuedThread() {
365          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
         Thread t1 = new Thread(new InterruptedSyncRunnable(sync));  
         Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));  
366          assertNull(sync.getFirstQueuedThread());          assertNull(sync.getFirstQueuedThread());
367          sync.acquire(1);          sync.acquire();
368          t1.start();          Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync));
369          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t1);
370          assertEquals(t1, sync.getFirstQueuedThread());          assertEquals(t1, sync.getFirstQueuedThread());
371          t2.start();          Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync));
372          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t2);
373          assertEquals(t1, sync.getFirstQueuedThread());          assertEquals(t1, sync.getFirstQueuedThread());
374          t1.interrupt();          t1.interrupt();
375          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t1);
         Thread.sleep(SHORT_DELAY_MS);  
376          assertEquals(t2, sync.getFirstQueuedThread());          assertEquals(t2, sync.getFirstQueuedThread());
377          sync.release(1);          sync.release();
378          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t2);
379          assertNull(sync.getFirstQueuedThread());          assertNull(sync.getFirstQueuedThread());
         t1.join();  
         t2.join();  
380      }      }
381    
   
382      /**      /**
383       * hasContended reports false if no thread has ever blocked, else true       * hasContended reports false if no thread has ever blocked, else true
384       */       */
385      public void testHasContended() throws InterruptedException {      public void testHasContended() {
386          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
         Thread t1 = new Thread(new InterruptedSyncRunnable(sync));  
         Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));  
387          assertFalse(sync.hasContended());          assertFalse(sync.hasContended());
388          sync.acquire(1);          sync.acquire();
389          t1.start();          assertFalse(sync.hasContended());
390          Thread.sleep(SHORT_DELAY_MS);          Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync));
391            waitForQueuedThread(sync, t1);
392          assertTrue(sync.hasContended());          assertTrue(sync.hasContended());
393          t2.start();          Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync));
394          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t2);
395          assertTrue(sync.hasContended());          assertTrue(sync.hasContended());
396          t1.interrupt();          t1.interrupt();
397          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t1);
398          assertTrue(sync.hasContended());          assertTrue(sync.hasContended());
399          sync.release(1);          sync.release();
400          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t2);
401          assertTrue(sync.hasContended());          assertTrue(sync.hasContended());
         t1.join();  
         t2.join();  
402      }      }
403    
404      /**      /**
405       * getQueuedThreads includes waiting threads       * getQueuedThreads returns all waiting threads
406       */       */
407      public void testGetQueuedThreads() throws InterruptedException {      public void testGetQueuedThreads() {
408          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
409          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
410          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
411          assertTrue(sync.getQueuedThreads().isEmpty());          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
412          sync.acquire(1);          sync.acquire();
413          assertTrue(sync.getQueuedThreads().isEmpty());          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
414          t1.start();          t1.start();
415          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t1);
416            assertHasExclusiveQueuedThreads(sync, t1);
417          assertTrue(sync.getQueuedThreads().contains(t1));          assertTrue(sync.getQueuedThreads().contains(t1));
418            assertFalse(sync.getQueuedThreads().contains(t2));
419          t2.start();          t2.start();
420          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t2);
421            assertHasExclusiveQueuedThreads(sync, t1, t2);
422          assertTrue(sync.getQueuedThreads().contains(t1));          assertTrue(sync.getQueuedThreads().contains(t1));
423          assertTrue(sync.getQueuedThreads().contains(t2));          assertTrue(sync.getQueuedThreads().contains(t2));
424          t1.interrupt();          t1.interrupt();
425          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t1);
426          assertFalse(sync.getQueuedThreads().contains(t1));          assertHasExclusiveQueuedThreads(sync, t2);
427          assertTrue(sync.getQueuedThreads().contains(t2));          sync.release();
428          sync.release(1);          awaitTermination(t2);
429          Thread.sleep(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
         assertTrue(sync.getQueuedThreads().isEmpty());  
         t1.join();  
         t2.join();  
430      }      }
431    
432      /**      /**
433       * getExclusiveQueuedThreads includes waiting threads       * getExclusiveQueuedThreads returns all exclusive waiting threads
434       */       */
435      public void testGetExclusiveQueuedThreads() throws InterruptedException {      public void testGetExclusiveQueuedThreads() {
436          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
437          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
438          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
439          assertTrue(sync.getExclusiveQueuedThreads().isEmpty());          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
440          sync.acquire(1);          sync.acquire();
441          assertTrue(sync.getExclusiveQueuedThreads().isEmpty());          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
442          t1.start();          t1.start();
443          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t1);
444            assertHasExclusiveQueuedThreads(sync, t1);
445          assertTrue(sync.getExclusiveQueuedThreads().contains(t1));          assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
446            assertFalse(sync.getExclusiveQueuedThreads().contains(t2));
447          t2.start();          t2.start();
448          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t2);
449            assertHasExclusiveQueuedThreads(sync, t1, t2);
450          assertTrue(sync.getExclusiveQueuedThreads().contains(t1));          assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
451          assertTrue(sync.getExclusiveQueuedThreads().contains(t2));          assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
452          t1.interrupt();          t1.interrupt();
453          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t1);
454          assertFalse(sync.getExclusiveQueuedThreads().contains(t1));          assertHasExclusiveQueuedThreads(sync, t2);
455          assertTrue(sync.getExclusiveQueuedThreads().contains(t2));          sync.release();
456          sync.release(1);          awaitTermination(t2);
457          Thread.sleep(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
         assertTrue(sync.getExclusiveQueuedThreads().isEmpty());  
         t1.join();  
         t2.join();  
458      }      }
459    
460      /**      /**
461       * getSharedQueuedThreads does not include exclusively waiting threads       * getSharedQueuedThreads does not include exclusively waiting threads
462       */       */
463      public void testGetSharedQueuedThreads() throws InterruptedException {      public void testGetSharedQueuedThreads_Exclusive() {
464          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
         Thread t1 = new Thread(new InterruptedSyncRunnable(sync));  
         Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));  
465          assertTrue(sync.getSharedQueuedThreads().isEmpty());          assertTrue(sync.getSharedQueuedThreads().isEmpty());
466          sync.acquire(1);          sync.acquire();
467          assertTrue(sync.getSharedQueuedThreads().isEmpty());          assertTrue(sync.getSharedQueuedThreads().isEmpty());
468          t1.start();          Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync));
469          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t1);
470          assertTrue(sync.getSharedQueuedThreads().isEmpty());          assertTrue(sync.getSharedQueuedThreads().isEmpty());
471          t2.start();          Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync));
472          Thread.sleep(SHORT_DELAY_MS);          waitForQueuedThread(sync, t2);
473          assertTrue(sync.getSharedQueuedThreads().isEmpty());          assertTrue(sync.getSharedQueuedThreads().isEmpty());
474          t1.interrupt();          t1.interrupt();
475          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t1);
476          assertTrue(sync.getSharedQueuedThreads().isEmpty());          assertTrue(sync.getSharedQueuedThreads().isEmpty());
477          sync.release(1);          sync.release();
478          Thread.sleep(SHORT_DELAY_MS);          awaitTermination(t2);
479          assertTrue(sync.getSharedQueuedThreads().isEmpty());          assertTrue(sync.getSharedQueuedThreads().isEmpty());
         t1.join();  
         t2.join();  
480      }      }
481    
482      /**      /**
483       * tryAcquireNanos is interruptible.       * getSharedQueuedThreads returns all shared waiting threads
484         */
485        public void testGetSharedQueuedThreads_Shared() {
486            final BooleanLatch l = new BooleanLatch();
487            assertHasSharedQueuedThreads(l, NO_THREADS);
488            Thread t1 = newStartedThread(new CheckedInterruptedRunnable() {
489                public void realRun() throws InterruptedException {
490                    l.acquireSharedInterruptibly(0);
491                }});
492            waitForQueuedThread(l, t1);
493            assertHasSharedQueuedThreads(l, t1);
494            Thread t2 = newStartedThread(new CheckedRunnable() {
495                public void realRun() throws InterruptedException {
496                    l.acquireSharedInterruptibly(0);
497                }});
498            waitForQueuedThread(l, t2);
499            assertHasSharedQueuedThreads(l, t1, t2);
500            t1.interrupt();
501            awaitTermination(t1);
502            assertHasSharedQueuedThreads(l, t2);
503            assertTrue(l.releaseShared(0));
504            awaitTermination(t2);
505            assertHasSharedQueuedThreads(l, NO_THREADS);
506        }
507    
508        /**
509         * tryAcquireNanos is interruptible
510       */       */
511      public void testInterruptedException2() throws InterruptedException {      public void testTryAcquireNanos_Interruptible() {
512          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
513          sync.acquire(1);          sync.acquire();
514          Thread t = new Thread(new CheckedInterruptedRunnable() {          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
515              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
516                  sync.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000);                  sync.tryAcquireNanos(MILLISECONDS.toNanos(2 * LONG_DELAY_MS));
517              }});              }});
518    
519          t.start();          waitForQueuedThread(sync, t);
520          t.interrupt();          t.interrupt();
521          t.join();          awaitTermination(t);
522      }      }
523    
   
524      /**      /**
525       * TryAcquire on exclusively held sync fails       * tryAcquire on exclusively held sync fails
526       */       */
527      public void testTryAcquireWhenSynced() throws InterruptedException {      public void testTryAcquireWhenSynced() {
528          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
529          sync.acquire(1);          sync.acquire();
530          Thread t = new Thread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
531              public void realRun() {              public void realRun() {
532                  threadAssertFalse(sync.tryAcquire(1));                  assertFalse(sync.tryAcquire());
533              }});              }});
534    
535          t.start();          awaitTermination(t);
536          t.join();          sync.release();
         sync.release(1);  
537      }      }
538    
539      /**      /**
540       * tryAcquireNanos on an exclusively held sync times out       * tryAcquireNanos on an exclusively held sync times out
541       */       */
542      public void testAcquireNanos_Timeout() throws InterruptedException {      public void testAcquireNanos_Timeout() {
543          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
544          sync.acquire(1);          sync.acquire();
545          Thread t = new Thread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
546              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
547                  threadAssertFalse(sync.tryAcquireNanos(1, 1000 * 1000));                  long startTime = System.nanoTime();
548                    long nanos = MILLISECONDS.toNanos(timeoutMillis());
549                    assertFalse(sync.tryAcquireNanos(nanos));
550                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
551              }});              }});
552    
553          t.start();          awaitTermination(t);
554          t.join();          sync.release();
         sync.release(1);  
555      }      }
556    
   
557      /**      /**
558       * getState is true when acquired and false when not       * getState is true when acquired and false when not
559       */       */
560      public void testGetState() throws InterruptedException {      public void testGetState() {
561          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
562          sync.acquire(1);          sync.acquire();
563          assertTrue(sync.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
564          sync.release(1);          sync.release();
565          assertFalse(sync.isHeldExclusively());          assertFalse(sync.isHeldExclusively());
566          Thread t = new Thread(new CheckedRunnable() {  
567            final BooleanLatch acquired = new BooleanLatch();
568            final BooleanLatch done = new BooleanLatch();
569            Thread t = newStartedThread(new CheckedRunnable() {
570              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
571                  sync.acquire(1);                  sync.acquire();
572                  Thread.sleep(SMALL_DELAY_MS);                  assertTrue(acquired.releaseShared(0));
573                  sync.release(1);                  done.acquireShared(0);
574                    sync.release();
575              }});              }});
576    
577          t.start();          acquired.acquireShared(0);
         Thread.sleep(SHORT_DELAY_MS);  
578          assertTrue(sync.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
579          t.join();          assertTrue(done.releaseShared(0));
580            awaitTermination(t);
581          assertFalse(sync.isHeldExclusively());          assertFalse(sync.isHeldExclusively());
582      }      }
583    
   
     /**  
      * 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();  
     }  
   
584      /**      /**
585       * acquireInterruptibly succeeds when released, else is interruptible       * acquireInterruptibly succeeds when released, else is interruptible
586       */       */
587      public void testAcquireInterruptibly2() throws InterruptedException {      public void testAcquireInterruptibly() throws InterruptedException {
588          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
589          sync.acquireInterruptibly(1);          final BooleanLatch threadStarted = new BooleanLatch();
590          Thread t = new Thread(new InterruptedSyncRunnable(sync));          sync.acquireInterruptibly();
591          t.start();          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
592                public void realRun() throws InterruptedException {
593                    assertTrue(threadStarted.releaseShared(0));
594                    sync.acquireInterruptibly();
595                }});
596    
597            threadStarted.acquireShared(0);
598            waitForQueuedThread(sync, t);
599          t.interrupt();          t.interrupt();
600            awaitTermination(t);
601          assertTrue(sync.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
         t.join();  
602      }      }
603    
604      /**      /**
# Line 427  Line 606 
606       */       */
607      public void testOwns() {      public void testOwns() {
608          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
609          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
610          final Mutex sync2 = new Mutex();          final Mutex sync2 = new Mutex();
611          assertTrue(sync.owns(c));          assertTrue(sync.owns(c));
612          assertFalse(sync2.owns(c));          assertFalse(sync2.owns(c));
# Line 436  Line 615 
615      /**      /**
616       * Calling await without holding sync throws IllegalMonitorStateException       * Calling await without holding sync throws IllegalMonitorStateException
617       */       */
618      public void testAwait_IllegalMonitor() throws InterruptedException {      public void testAwait_IMSE() {
619          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
620          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
621            for (AwaitMethod awaitMethod : AwaitMethod.values()) {
622                long startTime = System.nanoTime();
623          try {          try {
624              c.await();                  await(c, awaitMethod);
625              shouldThrow();              shouldThrow();
626          } catch (IllegalMonitorStateException success) {}              } catch (IllegalMonitorStateException success) {
627                } catch (InterruptedException e) { threadUnexpectedException(e); }
628                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
629            }
630      }      }
631    
632      /**      /**
633       * Calling signal without holding sync throws IllegalMonitorStateException       * Calling signal without holding sync throws IllegalMonitorStateException
634       */       */
635      public void testSignal_IllegalMonitor() {      public void testSignal_IMSE() {
636          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
637          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
638          try {          try {
639              c.signal();              c.signal();
640              shouldThrow();              shouldThrow();
641          } catch (IllegalMonitorStateException success) {}          } catch (IllegalMonitorStateException success) {}
642            assertHasWaitersUnlocked(sync, c, NO_THREADS);
643      }      }
644    
645      /**      /**
646       * 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  
647       */       */
648      public void testAwait_Timeout() throws InterruptedException {      public void testSignalAll_IMSE() {
649          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
650          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
651          sync.acquire(1);          try {
652          assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS));              c.signalAll();
653          sync.release(1);              shouldThrow();
654            } catch (IllegalMonitorStateException success) {}
655      }      }
656    
657      /**      /**
658       * awaitUntil without a signal times out       * await/awaitNanos/awaitUntil without a signal times out
659       */       */
660      public void testAwaitUntil_Timeout() throws InterruptedException {      public void testAwaitTimed_Timeout() { testAwait_Timeout(AwaitMethod.awaitTimed); }
661        public void testAwaitNanos_Timeout() { testAwait_Timeout(AwaitMethod.awaitNanos); }
662        public void testAwaitUntil_Timeout() { testAwait_Timeout(AwaitMethod.awaitUntil); }
663        public void testAwait_Timeout(AwaitMethod awaitMethod) {
664          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
665          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
666          sync.acquire(1);          sync.acquire();
667          java.util.Date d = new java.util.Date();          assertAwaitTimesOut(c, awaitMethod);
668          assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));          sync.release();
         sync.release(1);  
669      }      }
670    
671      /**      /**
672       * await returns when signalled       * await/awaitNanos/awaitUntil returns when signalled
673       */       */
674      public void testAwait() throws InterruptedException {      public void testSignal_await()      { testSignal(AwaitMethod.await); }
675        public void testSignal_awaitTimed() { testSignal(AwaitMethod.awaitTimed); }
676        public void testSignal_awaitNanos() { testSignal(AwaitMethod.awaitNanos); }
677        public void testSignal_awaitUntil() { testSignal(AwaitMethod.awaitUntil); }
678        public void testSignal(final AwaitMethod awaitMethod) {
679          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
680          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
681          Thread t = new Thread(new CheckedRunnable() {          final BooleanLatch acquired = new BooleanLatch();
682            Thread t = newStartedThread(new CheckedRunnable() {
683              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
684                  sync.acquire(1);                  sync.acquire();
685                  c.await();                  assertTrue(acquired.releaseShared(0));
686                  sync.release(1);                  await(c, awaitMethod);
687                    sync.release();
688              }});              }});
689    
690          t.start();          acquired.acquireShared(0);
691          Thread.sleep(SHORT_DELAY_MS);          sync.acquire();
692          sync.acquire(1);          assertHasWaitersLocked(sync, c, t);
693            assertHasExclusiveQueuedThreads(sync, NO_THREADS);
694          c.signal();          c.signal();
695          sync.release(1);          assertHasWaitersLocked(sync, c, NO_THREADS);
696          t.join(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, t);
697          assertFalse(t.isAlive());          sync.release();
698            awaitTermination(t);
699      }      }
700    
   
   
701      /**      /**
702       * hasWaiters throws NPE if null       * hasWaiters(null) throws NullPointerException
703       */       */
704      public void testHasWaitersNPE() {      public void testHasWaitersNPE() {
705          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
# Line 528  Line 710 
710      }      }
711    
712      /**      /**
713       * getWaitQueueLength throws NPE if null       * getWaitQueueLength(null) throws NullPointerException
714       */       */
715      public void testGetWaitQueueLengthNPE() {      public void testGetWaitQueueLengthNPE() {
716          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
# Line 538  Line 720 
720          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
721      }      }
722    
   
723      /**      /**
724       * getWaitingThreads throws NPE if null       * getWaitingThreads(null) throws NullPointerException
725       */       */
726      public void testGetWaitingThreadsNPE() {      public void testGetWaitingThreadsNPE() {
727          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
# Line 550  Line 731 
731          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
732      }      }
733    
   
734      /**      /**
735       * hasWaiters throws IAE if not owned       * hasWaiters throws IllegalArgumentException if not owned
736       */       */
737      public void testHasWaitersIAE() {      public void testHasWaitersIAE() {
738          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
739          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
740          final Mutex sync2 = new Mutex();          final Mutex sync2 = new Mutex();
741          try {          try {
742              sync2.hasWaiters(c);              sync2.hasWaiters(c);
743              shouldThrow();              shouldThrow();
744          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
745            assertHasWaitersUnlocked(sync, c, NO_THREADS);
746      }      }
747    
748      /**      /**
749       * hasWaiters throws IMSE if not synced       * hasWaiters throws IllegalMonitorStateException if not synced
750       */       */
751      public void testHasWaitersIMSE() {      public void testHasWaitersIMSE() {
752          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
753          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
754          try {          try {
755              sync.hasWaiters(c);              sync.hasWaiters(c);
756              shouldThrow();              shouldThrow();
757          } catch (IllegalMonitorStateException success) {}          } catch (IllegalMonitorStateException success) {}
758            assertHasWaitersUnlocked(sync, c, NO_THREADS);
759      }      }
760    
   
761      /**      /**
762       * getWaitQueueLength throws IAE if not owned       * getWaitQueueLength throws IllegalArgumentException if not owned
763       */       */
764      public void testGetWaitQueueLengthIAE() {      public void testGetWaitQueueLengthIAE() {
765          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
766          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
767          final Mutex sync2 = new Mutex();          final Mutex sync2 = new Mutex();
768          try {          try {
769              sync2.getWaitQueueLength(c);              sync2.getWaitQueueLength(c);
770              shouldThrow();              shouldThrow();
771          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
772            assertHasWaitersUnlocked(sync, c, NO_THREADS);
773      }      }
774    
775      /**      /**
776       * getWaitQueueLength throws IMSE if not synced       * getWaitQueueLength throws IllegalMonitorStateException if not synced
777       */       */
778      public void testGetWaitQueueLengthIMSE() {      public void testGetWaitQueueLengthIMSE() {
779          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
780          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
781          try {          try {
782              sync.getWaitQueueLength(c);              sync.getWaitQueueLength(c);
783              shouldThrow();              shouldThrow();
784          } catch (IllegalMonitorStateException success) {}          } catch (IllegalMonitorStateException success) {}
785            assertHasWaitersUnlocked(sync, c, NO_THREADS);
786      }      }
787    
   
788      /**      /**
789       * getWaitingThreads throws IAE if not owned       * getWaitingThreads throws IllegalArgumentException if not owned
790       */       */
791      public void testGetWaitingThreadsIAE() {      public void testGetWaitingThreadsIAE() {
792          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
793          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
794          final Mutex sync2 = new Mutex();          final Mutex sync2 = new Mutex();
795          try {          try {
796              sync2.getWaitingThreads(c);              sync2.getWaitingThreads(c);
797              shouldThrow();              shouldThrow();
798          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
799            assertHasWaitersUnlocked(sync, c, NO_THREADS);
800      }      }
801    
802      /**      /**
803       * getWaitingThreads throws IMSE if not synced       * getWaitingThreads throws IllegalMonitorStateException if not synced
804       */       */
805      public void testGetWaitingThreadsIMSE() {      public void testGetWaitingThreadsIMSE() {
806          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
807          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
808          try {          try {
809              sync.getWaitingThreads(c);              sync.getWaitingThreads(c);
810              shouldThrow();              shouldThrow();
811          } catch (IllegalMonitorStateException success) {}          } catch (IllegalMonitorStateException success) {}
812            assertHasWaitersUnlocked(sync, c, NO_THREADS);
813      }      }
814    
   
   
815      /**      /**
816       * hasWaiters returns true when a thread is waiting, else false       * hasWaiters returns true when a thread is waiting, else false
817       */       */
818      public void testHasWaiters() throws InterruptedException {      public void testHasWaiters() {
819          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
820          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
821          Thread t = new Thread(new CheckedRunnable() {          final BooleanLatch acquired = new BooleanLatch();
822            Thread t = newStartedThread(new CheckedRunnable() {
823              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
824                  sync.acquire(1);                  sync.acquire();
825                  threadAssertFalse(sync.hasWaiters(c));                  assertHasWaitersLocked(sync, c, NO_THREADS);
826                  threadAssertEquals(0, sync.getWaitQueueLength(c));                  assertFalse(sync.hasWaiters(c));
827                    assertTrue(acquired.releaseShared(0));
828                  c.await();                  c.await();
829                  sync.release(1);                  sync.release();
830              }});              }});
831    
832          t.start();          acquired.acquireShared(0);
833          Thread.sleep(SHORT_DELAY_MS);          sync.acquire();
834          sync.acquire(1);          assertHasWaitersLocked(sync, c, t);
835            assertHasExclusiveQueuedThreads(sync, NO_THREADS);
836          assertTrue(sync.hasWaiters(c));          assertTrue(sync.hasWaiters(c));
         assertEquals(1, sync.getWaitQueueLength(c));  
837          c.signal();          c.signal();
838          sync.release(1);          assertHasWaitersLocked(sync, c, NO_THREADS);
839          Thread.sleep(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, t);
         sync.acquire(1);  
840          assertFalse(sync.hasWaiters(c));          assertFalse(sync.hasWaiters(c));
841          assertEquals(0, sync.getWaitQueueLength(c));          sync.release();
842          sync.release(1);  
843          t.join(SHORT_DELAY_MS);          awaitTermination(t);
844          assertFalse(t.isAlive());          assertHasWaitersUnlocked(sync, c, NO_THREADS);
845      }      }
846    
847      /**      /**
848       * getWaitQueueLength returns number of waiting threads       * getWaitQueueLength returns number of waiting threads
849       */       */
850      public void testGetWaitQueueLength() throws InterruptedException {      public void testGetWaitQueueLength() {
851          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
852          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
853          Thread t1 = new Thread(new CheckedRunnable() {          final BooleanLatch acquired1 = new BooleanLatch();
854            final BooleanLatch acquired2 = new BooleanLatch();
855            final Thread t1 = newStartedThread(new CheckedRunnable() {
856              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
857                  sync.acquire(1);                  sync.acquire();
858                  threadAssertFalse(sync.hasWaiters(c));                  assertHasWaitersLocked(sync, c, NO_THREADS);
859                  threadAssertEquals(0, sync.getWaitQueueLength(c));                  assertEquals(0, sync.getWaitQueueLength(c));
860                    assertTrue(acquired1.releaseShared(0));
861                  c.await();                  c.await();
862                  sync.release(1);                  sync.release();
863              }});              }});
864            acquired1.acquireShared(0);
865            sync.acquire();
866            assertHasWaitersLocked(sync, c, t1);
867            assertEquals(1, sync.getWaitQueueLength(c));
868            sync.release();
869    
870          Thread t2 = new Thread(new CheckedRunnable() {          final Thread t2 = newStartedThread(new CheckedRunnable() {
871              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
872                  sync.acquire(1);                  sync.acquire();
873                  threadAssertTrue(sync.hasWaiters(c));                  assertHasWaitersLocked(sync, c, t1);
874                  threadAssertEquals(1, sync.getWaitQueueLength(c));                  assertEquals(1, sync.getWaitQueueLength(c));
875                    assertTrue(acquired2.releaseShared(0));
876                  c.await();                  c.await();
877                  sync.release(1);                  sync.release();
878              }});              }});
879            acquired2.acquireShared(0);
880          t1.start();          sync.acquire();
881          Thread.sleep(SHORT_DELAY_MS);          assertHasWaitersLocked(sync, c, t1, t2);
882          t2.start();          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
         Thread.sleep(SHORT_DELAY_MS);  
         sync.acquire(1);  
         assertTrue(sync.hasWaiters(c));  
883          assertEquals(2, sync.getWaitQueueLength(c));          assertEquals(2, sync.getWaitQueueLength(c));
884          c.signalAll();          c.signalAll();
885          sync.release(1);          assertHasWaitersLocked(sync, c, NO_THREADS);
886          Thread.sleep(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, t1, t2);
         sync.acquire(1);  
         assertFalse(sync.hasWaiters(c));  
887          assertEquals(0, sync.getWaitQueueLength(c));          assertEquals(0, sync.getWaitQueueLength(c));
888          sync.release(1);          sync.release();
889          t1.join(SHORT_DELAY_MS);  
890          t2.join(SHORT_DELAY_MS);          awaitTermination(t1);
891          assertFalse(t1.isAlive());          awaitTermination(t2);
892          assertFalse(t2.isAlive());          assertHasWaitersUnlocked(sync, c, NO_THREADS);
893      }      }
894    
895      /**      /**
896       * getWaitingThreads returns only and all waiting threads       * getWaitingThreads returns only and all waiting threads
897       */       */
898      public void testGetWaitingThreads() throws InterruptedException {      public void testGetWaitingThreads() {
899          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
900          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
901          Thread t1 = new Thread(new CheckedRunnable() {          final BooleanLatch acquired1 = new BooleanLatch();
902            final BooleanLatch acquired2 = new BooleanLatch();
903            final Thread t1 = new Thread(new CheckedRunnable() {
904              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
905                  sync.acquire(1);                  sync.acquire();
906                  threadAssertTrue(sync.getWaitingThreads(c).isEmpty());                  assertHasWaitersLocked(sync, c, NO_THREADS);
907                    assertTrue(sync.getWaitingThreads(c).isEmpty());
908                    assertTrue(acquired1.releaseShared(0));
909                  c.await();                  c.await();
910                  sync.release(1);                  sync.release();
911              }});              }});
912    
913          Thread t2 = new Thread(new CheckedRunnable() {          final Thread t2 = new Thread(new CheckedRunnable() {
914              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
915                  sync.acquire(1);                  sync.acquire();
916                  threadAssertFalse(sync.getWaitingThreads(c).isEmpty());                  assertHasWaitersLocked(sync, c, t1);
917                    assertTrue(sync.getWaitingThreads(c).contains(t1));
918                    assertFalse(sync.getWaitingThreads(c).isEmpty());
919                    assertEquals(1, sync.getWaitingThreads(c).size());
920                    assertTrue(acquired2.releaseShared(0));
921                  c.await();                  c.await();
922                  sync.release(1);                  sync.release();
923              }});              }});
924    
925          sync.acquire(1);          sync.acquire();
926            assertHasWaitersLocked(sync, c, NO_THREADS);
927            assertFalse(sync.getWaitingThreads(c).contains(t1));
928            assertFalse(sync.getWaitingThreads(c).contains(t2));
929          assertTrue(sync.getWaitingThreads(c).isEmpty());          assertTrue(sync.getWaitingThreads(c).isEmpty());
930          sync.release(1);          assertEquals(0, sync.getWaitingThreads(c).size());
931            sync.release();
932    
933          t1.start();          t1.start();
934          Thread.sleep(SHORT_DELAY_MS);          acquired1.acquireShared(0);
935            sync.acquire();
936            assertHasWaitersLocked(sync, c, t1);
937            assertTrue(sync.getWaitingThreads(c).contains(t1));
938            assertFalse(sync.getWaitingThreads(c).contains(t2));
939            assertFalse(sync.getWaitingThreads(c).isEmpty());
940            assertEquals(1, sync.getWaitingThreads(c).size());
941            sync.release();
942    
943          t2.start();          t2.start();
944          Thread.sleep(SHORT_DELAY_MS);          acquired2.acquireShared(0);
945          sync.acquire(1);          sync.acquire();
946          assertTrue(sync.hasWaiters(c));          assertHasWaitersLocked(sync, c, t1, t2);
947            assertHasExclusiveQueuedThreads(sync, NO_THREADS);
948          assertTrue(sync.getWaitingThreads(c).contains(t1));          assertTrue(sync.getWaitingThreads(c).contains(t1));
949          assertTrue(sync.getWaitingThreads(c).contains(t2));          assertTrue(sync.getWaitingThreads(c).contains(t2));
950            assertFalse(sync.getWaitingThreads(c).isEmpty());
951            assertEquals(2, sync.getWaitingThreads(c).size());
952          c.signalAll();          c.signalAll();
953          sync.release(1);          assertHasWaitersLocked(sync, c, NO_THREADS);
954          Thread.sleep(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, t1, t2);
955          sync.acquire(1);          assertFalse(sync.getWaitingThreads(c).contains(t1));
956          assertFalse(sync.hasWaiters(c));          assertFalse(sync.getWaitingThreads(c).contains(t2));
957          assertTrue(sync.getWaitingThreads(c).isEmpty());          assertTrue(sync.getWaitingThreads(c).isEmpty());
958          sync.release(1);          assertEquals(0, sync.getWaitingThreads(c).size());
959          t1.join(SHORT_DELAY_MS);          sync.release();
         t2.join(SHORT_DELAY_MS);  
         assertFalse(t1.isAlive());  
         assertFalse(t2.isAlive());  
     }  
   
960    
961            awaitTermination(t1);
962            awaitTermination(t2);
963            assertHasWaitersUnlocked(sync, c, NO_THREADS);
964        }
965    
966      /**      /**
967       * awaitUninterruptibly doesn't abort on interrupt       * awaitUninterruptibly is uninterruptible
968       */       */
969      public void testAwaitUninterruptibly() throws InterruptedException {      public void testAwaitUninterruptibly() {
970          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
971          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
972          Thread t = new Thread(new CheckedRunnable() {          final BooleanLatch pleaseInterrupt = new BooleanLatch();
973            Thread t = newStartedThread(new CheckedRunnable() {
974              public void realRun() {              public void realRun() {
975                  sync.acquire(1);                  sync.acquire();
976                    assertTrue(pleaseInterrupt.releaseShared(0));
977                  c.awaitUninterruptibly();                  c.awaitUninterruptibly();
978                  sync.release(1);                  assertTrue(Thread.interrupted());
979                    assertHasWaitersLocked(sync, c, NO_THREADS);
980                    sync.release();
981              }});              }});
982    
983          t.start();          pleaseInterrupt.acquireShared(0);
984          Thread.sleep(SHORT_DELAY_MS);          sync.acquire();
985            assertHasWaitersLocked(sync, c, t);
986            sync.release();
987          t.interrupt();          t.interrupt();
988          sync.acquire(1);          assertHasWaitersUnlocked(sync, c, t);
989            assertThreadStaysAlive(t);
990            sync.acquire();
991            assertHasWaitersLocked(sync, c, t);
992            assertHasExclusiveQueuedThreads(sync, NO_THREADS);
993          c.signal();          c.signal();
994          sync.release(1);          assertHasWaitersLocked(sync, c, NO_THREADS);
995          t.join(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, t);
996          assertFalse(t.isAlive());          sync.release();
997            awaitTermination(t);
998      }      }
999    
1000      /**      /**
1001       * await is interruptible       * await/awaitNanos/awaitUntil is interruptible
1002       */       */
1003      public void testAwait_Interrupt() throws InterruptedException {      public void testInterruptible_await()      { testInterruptible(AwaitMethod.await); }
1004        public void testInterruptible_awaitTimed() { testInterruptible(AwaitMethod.awaitTimed); }
1005        public void testInterruptible_awaitNanos() { testInterruptible(AwaitMethod.awaitNanos); }
1006        public void testInterruptible_awaitUntil() { testInterruptible(AwaitMethod.awaitUntil); }
1007        public void testInterruptible(final AwaitMethod awaitMethod) {
1008          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
1009          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final ConditionObject c = sync.newCondition();
1010          Thread t = new Thread(new CheckedInterruptedRunnable() {          final BooleanLatch pleaseInterrupt = new BooleanLatch();
1011            Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1012              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
1013                  sync.acquire(1);                  sync.acquire();
1014                  c.await();                  assertTrue(pleaseInterrupt.releaseShared(0));
1015                    await(c, awaitMethod);
1016              }});              }});
1017    
1018          t.start();          pleaseInterrupt.acquireShared(0);
         Thread.sleep(SHORT_DELAY_MS);  
1019          t.interrupt();          t.interrupt();
1020          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(1000 * 1000 * 1000); // 1 sec  
             }});  
   
         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());  
1021      }      }
1022    
1023      /**      /**
1024       * signalAll wakes up all threads       * signalAll wakes up all threads
1025       */       */
1026      public void testSignalAll() throws InterruptedException {      public void testSignalAll_await()      { testSignalAll(AwaitMethod.await); }
1027          final Mutex sync = new Mutex();      public void testSignalAll_awaitTimed() { testSignalAll(AwaitMethod.awaitTimed); }
1028          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();      public void testSignalAll_awaitNanos() { testSignalAll(AwaitMethod.awaitNanos); }
1029          Thread t1 = new Thread(new CheckedRunnable() {      public void testSignalAll_awaitUntil() { testSignalAll(AwaitMethod.awaitUntil); }
1030              public void realRun() throws InterruptedException {      public void testSignalAll(final AwaitMethod awaitMethod) {
1031                  sync.acquire(1);          final Mutex sync = new Mutex();
1032                  c.await();          final ConditionObject c = sync.newCondition();
1033                  sync.release(1);          final BooleanLatch acquired1 = new BooleanLatch();
1034              }});          final BooleanLatch acquired2 = new BooleanLatch();
1035            Thread t1 = newStartedThread(new CheckedRunnable() {
1036          Thread t2 = new Thread(new CheckedRunnable() {              public void realRun() throws InterruptedException {
1037              public void realRun() throws InterruptedException {                  sync.acquire();
1038                  sync.acquire(1);                  acquired1.releaseShared(0);
1039                  c.await();                  await(c, awaitMethod);
1040                  sync.release(1);                  sync.release();
1041              }});              }});
1042    
1043          t1.start();          Thread t2 = newStartedThread(new CheckedRunnable() {
1044          t2.start();              public void realRun() throws InterruptedException {
1045          Thread.sleep(SHORT_DELAY_MS);                  sync.acquire();
1046          sync.acquire(1);                  acquired2.releaseShared(0);
1047                    await(c, awaitMethod);
1048                    sync.release();
1049                }});
1050    
1051            acquired1.acquireShared(0);
1052            acquired2.acquireShared(0);
1053            sync.acquire();
1054            assertHasWaitersLocked(sync, c, t1, t2);
1055            assertHasExclusiveQueuedThreads(sync, NO_THREADS);
1056          c.signalAll();          c.signalAll();
1057          sync.release(1);          assertHasWaitersLocked(sync, c, NO_THREADS);
1058          t1.join(SHORT_DELAY_MS);          assertHasExclusiveQueuedThreads(sync, t1, t2);
1059          t2.join(SHORT_DELAY_MS);          sync.release();
1060          assertFalse(t1.isAlive());          awaitTermination(t1);
1061          assertFalse(t2.isAlive());          awaitTermination(t2);
1062      }      }
1063    
   
1064      /**      /**
1065       * toString indicates current state       * toString indicates current state
1066       */       */
1067      public void testToString() {      public void testToString() {
1068          Mutex sync = new Mutex();          Mutex sync = new Mutex();
1069          String us = sync.toString();          assertTrue(sync.toString().contains("State = " + Mutex.UNLOCKED));
1070          assertTrue(us.indexOf("State = 0") >= 0);          sync.acquire();
1071          sync.acquire(1);          assertTrue(sync.toString().contains("State = " + Mutex.LOCKED));
         String ls = sync.toString();  
         assertTrue(ls.indexOf("State = 1") >= 0);  
1072      }      }
1073    
1074      /**      /**
1075       * A serialized AQS deserializes with current state       * A serialized AQS deserializes with current state, but no queued threads
1076       */       */
1077      public void testSerialization() throws Exception {      public void testSerialization() {
1078          Mutex l = new Mutex();          Mutex sync = new Mutex();
1079          l.acquire(1);          assertFalse(serialClone(sync).isHeldExclusively());
1080          assertTrue(l.isHeldExclusively());          sync.acquire();
1081            Thread t = newStartedThread(new InterruptedSyncRunnable(sync));
1082          ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);          waitForQueuedThread(sync, t);
1083          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());  
     }  
1084    
1085            Mutex clone = serialClone(sync);
1086            assertTrue(clone.isHeldExclusively());
1087            assertHasExclusiveQueuedThreads(sync, t);
1088            assertHasExclusiveQueuedThreads(clone, NO_THREADS);
1089            t.interrupt();
1090            awaitTermination(t);
1091            sync.release();
1092            assertFalse(sync.isHeldExclusively());
1093            assertTrue(clone.isHeldExclusively());
1094            assertHasExclusiveQueuedThreads(sync, NO_THREADS);
1095            assertHasExclusiveQueuedThreads(clone, NO_THREADS);
1096        }
1097    
1098      /**      /**
1099       * tryReleaseShared setting state changes getState       * tryReleaseShared setting state changes getState
# Line 905  Line 1101 
1101      public void testGetStateWithReleaseShared() {      public void testGetStateWithReleaseShared() {
1102          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1103          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1104          l.releaseShared(0);          assertTrue(l.releaseShared(0));
1105          assertTrue(l.isSignalled());          assertTrue(l.isSignalled());
1106      }      }
1107    
# Line 915  Line 1111 
1111      public void testReleaseShared() {      public void testReleaseShared() {
1112          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1113          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1114          l.releaseShared(0);          assertTrue(l.releaseShared(0));
1115          assertTrue(l.isSignalled());          assertTrue(l.isSignalled());
1116          l.releaseShared(0);          assertTrue(l.releaseShared(0));
1117          assertTrue(l.isSignalled());          assertTrue(l.isSignalled());
1118      }      }
1119    
1120      /**      /**
1121       * acquireSharedInterruptibly returns after release, but not before       * acquireSharedInterruptibly returns after release, but not before
1122       */       */
1123      public void testAcquireSharedInterruptibly() throws InterruptedException {      public void testAcquireSharedInterruptibly() {
1124          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1125    
1126          Thread t = new Thread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
1127              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
1128                  threadAssertFalse(l.isSignalled());                  assertFalse(l.isSignalled());
1129                    l.acquireSharedInterruptibly(0);
1130                    assertTrue(l.isSignalled());
1131                  l.acquireSharedInterruptibly(0);                  l.acquireSharedInterruptibly(0);
1132                  threadAssertTrue(l.isSignalled());                  assertTrue(l.isSignalled());
1133              }});              }});
1134    
1135          t.start();          waitForQueuedThread(l, t);
1136          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1137          Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
1138          l.releaseShared(0);          assertHasSharedQueuedThreads(l, t);
1139            assertTrue(l.releaseShared(0));
1140          assertTrue(l.isSignalled());          assertTrue(l.isSignalled());
1141          t.join();          awaitTermination(t);
1142      }      }
1143    
   
1144      /**      /**
1145       * acquireSharedTimed returns after release       * tryAcquireSharedNanos returns after release, but not before
1146       */       */
1147      public void testAsquireSharedTimed() throws InterruptedException {      public void testTryAcquireSharedNanos() {
1148          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1149    
1150          Thread t = new Thread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
1151              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
1152                  threadAssertFalse(l.isSignalled());                  assertFalse(l.isSignalled());
1153                  threadAssertTrue(l.tryAcquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000));                  long nanos = MILLISECONDS.toNanos(2 * LONG_DELAY_MS);
1154                  threadAssertTrue(l.isSignalled());                  assertTrue(l.tryAcquireSharedNanos(0, nanos));
1155                    assertTrue(l.isSignalled());
1156                    assertTrue(l.tryAcquireSharedNanos(0, nanos));
1157                    assertTrue(l.isSignalled());
1158              }});              }});
1159    
1160          t.start();          waitForQueuedThread(l, t);
1161          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1162          Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
1163          l.releaseShared(0);          assertTrue(l.releaseShared(0));
1164          assertTrue(l.isSignalled());          assertTrue(l.isSignalled());
1165          t.join();          awaitTermination(t);
1166      }      }
1167    
1168      /**      /**
1169       * acquireSharedInterruptibly throws IE if interrupted before released       * acquireSharedInterruptibly is interruptible
1170       */       */
1171      public void testAcquireSharedInterruptibly_InterruptedException() throws InterruptedException {      public void testAcquireSharedInterruptibly_Interruptible() {
1172          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1173          Thread t = new Thread(new CheckedInterruptedRunnable() {          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1174              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
1175                  threadAssertFalse(l.isSignalled());                  assertFalse(l.isSignalled());
1176                  l.acquireSharedInterruptibly(0);                  l.acquireSharedInterruptibly(0);
1177              }});              }});
1178    
1179          t.start();          waitForQueuedThread(l, t);
1180          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1181          t.interrupt();          t.interrupt();
1182          t.join();          awaitTermination(t);
1183            assertFalse(l.isSignalled());
1184      }      }
1185    
1186      /**      /**
1187       * acquireSharedTimed throws IE if interrupted before released       * tryAcquireSharedNanos is interruptible
1188       */       */
1189      public void testAcquireSharedNanos_InterruptedException() throws InterruptedException {      public void testTryAcquireSharedNanos_Interruptible() {
1190          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1191          Thread t = new Thread(new CheckedInterruptedRunnable() {          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1192              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
1193                  threadAssertFalse(l.isSignalled());                  assertFalse(l.isSignalled());
1194                  l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000);                  long nanos = MILLISECONDS.toNanos(2 * LONG_DELAY_MS);
1195                    l.tryAcquireSharedNanos(0, nanos);
1196              }});              }});
1197    
1198          t.start();          waitForQueuedThread(l, t);
         Thread.sleep(SHORT_DELAY_MS);  
1199          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1200          t.interrupt();          t.interrupt();
1201          t.join();          awaitTermination(t);
1202            assertFalse(l.isSignalled());
1203      }      }
1204    
1205      /**      /**
1206       * acquireSharedTimed times out if not released before timeout       * tryAcquireSharedNanos times out if not released before timeout
1207       */       */
1208      public void testAcquireSharedNanos_Timeout() throws InterruptedException {      public void testTryAcquireSharedNanos_Timeout() {
1209          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1210          Thread t = new Thread(new CheckedRunnable() {          final BooleanLatch observedQueued = new BooleanLatch();
1211            Thread t = newStartedThread(new CheckedRunnable() {
1212              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
1213                  threadAssertFalse(l.isSignalled());                  assertFalse(l.isSignalled());
1214                  threadAssertFalse(l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000));                  for (long millis = timeoutMillis();
1215                         !observedQueued.isSignalled();
1216                         millis *= 2) {
1217                        long nanos = MILLISECONDS.toNanos(millis);
1218                        long startTime = System.nanoTime();
1219                        assertFalse(l.tryAcquireSharedNanos(0, nanos));
1220                        assertTrue(millisElapsedSince(startTime) >= millis);
1221                    }
1222                    assertFalse(l.isSignalled());
1223              }});              }});
1224    
1225          t.start();          waitForQueuedThread(l, t);
1226          Thread.sleep(SHORT_DELAY_MS);          observedQueued.releaseShared(0);
1227          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1228          t.join();          awaitTermination(t);
1229            assertFalse(l.isSignalled());
1230        }
1231    
1232        /**
1233         * awaitNanos/timed await with 0 wait times out immediately
1234         */
1235        public void testAwait_Zero() throws InterruptedException {
1236            final Mutex sync = new Mutex();
1237            final ConditionObject c = sync.newCondition();
1238            sync.acquire();
1239            assertTrue(c.awaitNanos(0L) <= 0);
1240            assertFalse(c.await(0L, NANOSECONDS));
1241            sync.release();
1242        }
1243    
1244        /**
1245         * awaitNanos/timed await with maximum negative wait times does not underflow
1246         */
1247        public void testAwait_NegativeInfinity() throws InterruptedException {
1248            final Mutex sync = new Mutex();
1249            final ConditionObject c = sync.newCondition();
1250            sync.acquire();
1251            assertTrue(c.awaitNanos(Long.MIN_VALUE) <= 0);
1252            assertFalse(c.await(Long.MIN_VALUE, NANOSECONDS));
1253            sync.release();
1254      }      }
1255    
1256  }  }

Legend:
Removed from v.1.31  
changed lines
  Added in v.1.52

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8