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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8