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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8