--- jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java 2004/01/09 14:45:58 1.12 +++ jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java 2009/11/18 08:26:24 1.27 @@ -2,8 +2,8 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ @@ -30,41 +30,34 @@ public class AbstractQueuedSynchronizerT * ReentrantReadWriteLock, and Semaphore */ static class Mutex extends AbstractQueuedSynchronizer { - public boolean isLocked() { return getState() == 1; } - - public boolean tryAcquireExclusive(int acquires) { - assertTrue(acquires == 1); + public boolean isHeldExclusively() { return getState() == 1; } + + public boolean tryAcquire(int acquires) { + assertTrue(acquires == 1); return compareAndSetState(0, 1); } - - public boolean tryReleaseExclusive(int releases) { + + public boolean tryRelease(int releases) { + if (getState() == 0) throw new IllegalMonitorStateException(); setState(0); return true; } - - public void checkConditionAccess(Thread thread) { - if (getState() == 0) throw new IllegalMonitorStateException(); - } - - public ConditionObject newCondition() { return new ConditionObject(); } - - public void lock() { - acquireExclusiveUninterruptibly(1); - } + + public AbstractQueuedSynchronizer.ConditionObject newCondition() { return new AbstractQueuedSynchronizer.ConditionObject(); } } - + /** * A simple latch class, to test shared mode. */ - static class BooleanLatch extends AbstractQueuedSynchronizer { + static class BooleanLatch extends AbstractQueuedSynchronizer { public boolean isSignalled() { return getState() != 0; } public int tryAcquireShared(int ignore) { return isSignalled()? 1 : -1; } - + public boolean tryReleaseShared(int ignore) { setState(1); return true; @@ -72,459 +65,935 @@ public class AbstractQueuedSynchronizerT } /** - * A runnable calling acquireExclusiveInterruptibly + * A runnable calling acquireInterruptibly */ - class InterruptibleLockRunnable implements Runnable { - final Mutex lock; - InterruptibleLockRunnable(Mutex l) { lock = l; } + class InterruptibleSyncRunnable implements Runnable { + final Mutex sync; + InterruptibleSyncRunnable(Mutex l) { sync = l; } public void run() { try { - lock.acquireExclusiveInterruptibly(1); - } catch(InterruptedException success){} + sync.acquireInterruptibly(1); + } catch (InterruptedException success) {} } } /** - * A runnable calling acquireExclusiveInterruptibly that expects to be + * A runnable calling acquireInterruptibly that expects to be * interrupted */ - class InterruptedLockRunnable implements Runnable { - final Mutex lock; - InterruptedLockRunnable(Mutex l) { lock = l; } + class InterruptedSyncRunnable implements Runnable { + final Mutex sync; + InterruptedSyncRunnable(Mutex l) { sync = l; } public void run() { try { - lock.acquireExclusiveInterruptibly(1); + sync.acquireInterruptibly(1); threadShouldThrow(); - } catch(InterruptedException success){} + } catch (InterruptedException success) {} } } - + /** - * acquireExclusiveUninterruptiblying an releaseExclusiveed lock succeeds + * isHeldExclusively is false upon construction */ - public void testAcquireExclusiveUninterruptibly() { + public void testIsHeldExclusively() { Mutex rl = new Mutex(); - rl.acquireExclusiveUninterruptibly(1); - assertTrue(rl.isLocked()); - rl.releaseExclusive(1); + assertFalse(rl.isHeldExclusively()); } /** - * tryAcquireExclusive on an releaseExclusiveed lock succeeds + * acquiring released sync succeeds */ - public void testTryAcquireExclusive() { + public void testAcquire() { Mutex rl = new Mutex(); - assertTrue(rl.tryAcquireExclusive(1)); - assertTrue(rl.isLocked()); - rl.releaseExclusive(1); + rl.acquire(1); + assertTrue(rl.isHeldExclusively()); + rl.release(1); + assertFalse(rl.isHeldExclusively()); + } + + /** + * tryAcquire on an released sync succeeds + */ + public void testTryAcquire() { + Mutex rl = new Mutex(); + assertTrue(rl.tryAcquire(1)); + assertTrue(rl.isHeldExclusively()); + rl.release(1); } /** * hasQueuedThreads reports whether there are waiting threads */ - public void testhasQueuedThreads() { - final Mutex lock = new Mutex(); - Thread t1 = new Thread(new InterruptedLockRunnable(lock)); - Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertFalse(lock.hasQueuedThreads()); - lock.acquireExclusiveUninterruptibly(1); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasQueuedThreads()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasQueuedThreads()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasQueuedThreads()); - lock.releaseExclusive(1); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(lock.hasQueuedThreads()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } + public void testhasQueuedThreads() throws InterruptedException { + final Mutex sync = new Mutex(); + Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); + Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); + assertFalse(sync.hasQueuedThreads()); + sync.acquire(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasQueuedThreads()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasQueuedThreads()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasQueuedThreads()); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.hasQueuedThreads()); + t1.join(); + t2.join(); + } /** * isQueued(null) throws NPE */ - public void testIsQueuedNPE() { - final Mutex lock = new Mutex(); + public void testIsQueuedNPE() { + final Mutex sync = new Mutex(); try { - lock.isQueued(null); + sync.isQueued(null); shouldThrow(); - } catch (NullPointerException success) { - } + } catch (NullPointerException success) {} } /** * isQueued reports whether a thread is queued. */ - public void testIsQueued() { - final Mutex lock = new Mutex(); - Thread t1 = new Thread(new InterruptedLockRunnable(lock)); - Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertFalse(lock.isQueued(t1)); - assertFalse(lock.isQueued(t2)); - lock.acquireExclusiveUninterruptibly(1); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.isQueued(t1)); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.isQueued(t1)); - assertTrue(lock.isQueued(t2)); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(lock.isQueued(t1)); - assertTrue(lock.isQueued(t2)); - lock.releaseExclusive(1); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(lock.isQueued(t1)); - assertFalse(lock.isQueued(t2)); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } + public void testIsQueued() throws InterruptedException { + final Mutex sync = new Mutex(); + Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); + Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); + assertFalse(sync.isQueued(t1)); + assertFalse(sync.isQueued(t2)); + sync.acquire(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.isQueued(t1)); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.isQueued(t1)); + assertTrue(sync.isQueued(t2)); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.isQueued(t1)); + assertTrue(sync.isQueued(t2)); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.isQueued(t1)); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.isQueued(t2)); + t1.join(); + t2.join(); + } /** - * getFirstQueuedThread returns first waiting thread or null is none - */ - public void testGetFirstQueuedThread() { - final Mutex lock = new Mutex(); - Thread t1 = new Thread(new InterruptedLockRunnable(lock)); - Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertNull(lock.getFirstQueuedThread()); - lock.acquireExclusiveUninterruptibly(1); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(t1, lock.getFirstQueuedThread()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(t1, lock.getFirstQueuedThread()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(t2, lock.getFirstQueuedThread()); - lock.releaseExclusive(1); - Thread.sleep(SHORT_DELAY_MS); - assertNull(lock.getFirstQueuedThread()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } + * getFirstQueuedThread returns first waiting thread or null if none + */ + public void testGetFirstQueuedThread() throws InterruptedException { + final Mutex sync = new Mutex(); + Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); + Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); + assertNull(sync.getFirstQueuedThread()); + sync.acquire(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(t1, sync.getFirstQueuedThread()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(t1, sync.getFirstQueuedThread()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(t2, sync.getFirstQueuedThread()); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertNull(sync.getFirstQueuedThread()); + t1.join(); + t2.join(); + } /** * hasContended reports false if no thread has ever blocked, else true */ - public void testHasContended() { - final Mutex lock = new Mutex(); - Thread t1 = new Thread(new InterruptedLockRunnable(lock)); - Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertFalse(lock.hasContended()); - lock.acquireExclusiveUninterruptibly(1); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasContended()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasContended()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasContended()); - lock.releaseExclusive(1); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasContended()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } - - /** - * timed tryAcquireExclusive is interruptible. - */ - public void testInterruptedException2() { - final Mutex lock = new Mutex(); - lock.acquireExclusiveUninterruptibly(1); + public void testHasContended() throws InterruptedException { + final Mutex sync = new Mutex(); + Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); + Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); + assertFalse(sync.hasContended()); + sync.acquire(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasContended()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasContended()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasContended()); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasContended()); + t1.join(); + t2.join(); + } + + /** + * getQueuedThreads includes waiting threads + */ + public void testGetQueuedThreads() throws InterruptedException { + final Mutex sync = new Mutex(); + Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); + Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); + assertTrue(sync.getQueuedThreads().isEmpty()); + sync.acquire(1); + assertTrue(sync.getQueuedThreads().isEmpty()); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getQueuedThreads().contains(t1)); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getQueuedThreads().contains(t1)); + assertTrue(sync.getQueuedThreads().contains(t2)); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.getQueuedThreads().contains(t1)); + assertTrue(sync.getQueuedThreads().contains(t2)); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getQueuedThreads().isEmpty()); + t1.join(); + t2.join(); + } + + /** + * getExclusiveQueuedThreads includes waiting threads + */ + public void testGetExclusiveQueuedThreads() throws InterruptedException { + final Mutex sync = new Mutex(); + Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); + Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); + assertTrue(sync.getExclusiveQueuedThreads().isEmpty()); + sync.acquire(1); + assertTrue(sync.getExclusiveQueuedThreads().isEmpty()); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getExclusiveQueuedThreads().contains(t1)); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getExclusiveQueuedThreads().contains(t1)); + assertTrue(sync.getExclusiveQueuedThreads().contains(t2)); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.getExclusiveQueuedThreads().contains(t1)); + assertTrue(sync.getExclusiveQueuedThreads().contains(t2)); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getExclusiveQueuedThreads().isEmpty()); + t1.join(); + t2.join(); + } + + /** + * getSharedQueuedThreads does not include exclusively waiting threads + */ + public void testGetSharedQueuedThreads() throws InterruptedException { + final Mutex sync = new Mutex(); + Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); + Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + sync.acquire(1); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + t1.join(); + t2.join(); + } + + /** + * tryAcquireNanos is interruptible. + */ + public void testInterruptedException2() throws InterruptedException { + final Mutex sync = new Mutex(); + sync.acquire(1); Thread t = new Thread(new Runnable() { public void run() { try { - lock.acquireExclusiveNanos(1, MEDIUM_DELAY_MS * 1000 * 1000); + sync.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000); threadShouldThrow(); - } catch(InterruptedException success){} + } catch (InterruptedException success) {} } }); - try { - t.start(); - t.interrupt(); - } catch(Exception e){ - unexpectedException(); - } + + t.start(); + t.interrupt(); + t.join(); } /** - * TryAcquireExclusive on a locked lock fails + * TryAcquire on exclusively held sync fails */ - public void testTryAcquireExclusiveWhenLocked() { - final Mutex lock = new Mutex(); - lock.acquireExclusiveUninterruptibly(1); + public void testTryAcquireWhenSynced() throws InterruptedException { + final Mutex sync = new Mutex(); + sync.acquire(1); Thread t = new Thread(new Runnable() { public void run() { - threadAssertFalse(lock.tryAcquireExclusive(1)); + threadAssertFalse(sync.tryAcquire(1)); } }); - try { - t.start(); - t.join(); - lock.releaseExclusive(1); - } catch(Exception e){ - unexpectedException(); - } - } + + t.start(); + t.join(); + sync.release(1); + } /** - * acquireExclusiveTimed on a locked lock times out + * tryAcquireNanos on an exclusively held sync times out */ - public void testacquireExclusiveTimed_Timeout() { - final Mutex lock = new Mutex(); - lock.acquireExclusiveUninterruptibly(1); + public void testAcquireNanos_Timeout() throws InterruptedException { + final Mutex sync = new Mutex(); + sync.acquire(1); Thread t = new Thread(new Runnable() { public void run() { try { - threadAssertFalse(lock.acquireExclusiveNanos(1, 1000 * 1000)); + threadAssertFalse(sync.tryAcquireNanos(1, 1000 * 1000)); } catch (Exception ex) { threadUnexpectedException(); } } }); - try { - t.start(); - t.join(); - lock.releaseExclusive(1); - } catch(Exception e){ - unexpectedException(); - } - } - - - /** - * isLocked is true when locked and false when not - */ - public void testIsLocked() { - final Mutex lock = new Mutex(); - lock.acquireExclusiveUninterruptibly(1); - assertTrue(lock.isLocked()); - lock.releaseExclusive(1); - assertFalse(lock.isLocked()); - Thread t = new Thread(new Runnable() { + + t.start(); + t.join(); + sync.release(1); + } + + + /** + * getState is true when acquired and false when not + */ + public void testGetState() throws InterruptedException { + final Mutex sync = new Mutex(); + sync.acquire(1); + assertTrue(sync.isHeldExclusively()); + sync.release(1); + assertFalse(sync.isHeldExclusively()); + Thread t = new Thread(new Runnable() { public void run() { - lock.acquireExclusiveUninterruptibly(1); + sync.acquire(1); try { Thread.sleep(SMALL_DELAY_MS); } - catch(Exception e) { + catch (Exception e) { threadUnexpectedException(); } - lock.releaseExclusive(1); + sync.release(1); } }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.isLocked()); - t.join(); - assertFalse(lock.isLocked()); - } catch(Exception e){ - unexpectedException(); - } + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.isHeldExclusively()); + t.join(); + assertFalse(sync.isHeldExclusively()); } /** - * acquireExclusiveInterruptibly is interruptible. + * acquireInterruptibly is interruptible. */ - public void testAcquireInterruptibly1() { - final Mutex lock = new Mutex(); - lock.acquireExclusiveUninterruptibly(1); - Thread t = new Thread(new InterruptedLockRunnable(lock)); - try { - t.start(); - t.interrupt(); - lock.releaseExclusive(1); - t.join(); - } catch(Exception e){ - unexpectedException(); - } - } + 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(); + } /** - * acquireExclusiveInterruptibly succeeds when released, else is interruptible + * acquireInterruptibly succeeds when released, else is interruptible */ - public void testAcquireInterruptibly2() { - final Mutex lock = new Mutex(); - try { - lock.acquireExclusiveInterruptibly(1); - } catch(Exception e) { - unexpectedException(); - } - Thread t = new Thread(new InterruptedLockRunnable(lock)); - try { - t.start(); - t.interrupt(); - assertTrue(lock.isLocked()); - t.join(); - } catch(Exception e){ - unexpectedException(); - } + public void testAcquireInterruptibly2() throws InterruptedException { + final Mutex sync = new Mutex(); + sync.acquireInterruptibly(1); + Thread t = new Thread(new InterruptedSyncRunnable(sync)); + t.start(); + t.interrupt(); + assertTrue(sync.isHeldExclusively()); + t.join(); } /** - * owns is true for a condition created by lock else false + * owns is true for a condition created by sync else false */ public void testOwns() { - final Mutex lock = new Mutex(); - final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition(); - final Mutex lock2 = new Mutex(); - assertTrue(lock.owns(c)); - assertFalse(lock2.owns(c)); + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + final Mutex sync2 = new Mutex(); + assertTrue(sync.owns(c)); + assertFalse(sync2.owns(c)); } /** - * Calling await without holding lock throws IllegalMonitorStateException + * Calling await without holding sync throws IllegalMonitorStateException */ - public void testAwait_IllegalMonitor() { - final Mutex lock = new Mutex(); - final Condition c = lock.newCondition(); + public void testAwait_IllegalMonitor() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); try { c.await(); shouldThrow(); } - catch (IllegalMonitorStateException success) { - } - catch (Exception ex) { - unexpectedException(); - } + catch (IllegalMonitorStateException success) {} } /** - * Calling signal without holding lock throws IllegalMonitorStateException + * Calling signal without holding sync throws IllegalMonitorStateException */ public void testSignal_IllegalMonitor() { - final Mutex lock = new Mutex(); - final Condition c = lock.newCondition(); + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); try { c.signal(); shouldThrow(); } - catch (IllegalMonitorStateException success) { - } - catch (Exception ex) { - unexpectedException(); - } + catch (IllegalMonitorStateException success) {} } /** * awaitNanos without a signal times out */ - public void testAwaitNanos_Timeout() { - final Mutex lock = new Mutex(); - final Condition c = lock.newCondition(); - try { - lock.acquireExclusiveUninterruptibly(1); - long t = c.awaitNanos(100); - assertTrue(t <= 0); - lock.releaseExclusive(1); - } - catch (Exception ex) { - unexpectedException(); - } + 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 - */ - public void testAwait_Timeout() { - final Mutex lock = new Mutex(); - final Condition c = lock.newCondition(); - try { - lock.acquireExclusiveUninterruptibly(1); - assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - lock.releaseExclusive(1); - } - catch (Exception ex) { - unexpectedException(); - } + * Timed await without a signal times out + */ + public void testAwait_Timeout() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + sync.acquire(1); + assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); + sync.release(1); } /** * awaitUntil without a signal times out */ - public void testAwaitUntil_Timeout() { - final Mutex lock = new Mutex(); - final Condition c = lock.newCondition(); - try { - lock.acquireExclusiveUninterruptibly(1); - java.util.Date d = new java.util.Date(); - assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10))); - lock.releaseExclusive(1); - } - catch (Exception ex) { - unexpectedException(); - } + public void testAwaitUntil_Timeout() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + sync.acquire(1); + java.util.Date d = new java.util.Date(); + assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10))); + sync.release(1); } /** * await returns when signalled */ - public void testAwait() { - final Mutex lock = new Mutex(); - final Condition c = lock.newCondition(); - Thread t = new Thread(new Runnable() { + public void testAwait() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + Thread t = new Thread(new Runnable() { public void run() { try { - lock.acquireExclusiveUninterruptibly(1); + sync.acquire(1); c.await(); - lock.releaseExclusive(1); + sync.release(1); } - catch(InterruptedException e) { + catch (InterruptedException e) { threadUnexpectedException(); } } }); + t.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + c.signal(); + sync.release(1); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); + } + + + + /** + * hasWaiters throws NPE if null + */ + public void testHasWaitersNPE() { + final Mutex sync = new Mutex(); try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.acquireExclusiveUninterruptibly(1); - c.signal(); - lock.releaseExclusive(1); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + sync.hasWaiters(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * getWaitQueueLength throws NPE if null + */ + public void testGetWaitQueueLengthNPE() { + final Mutex sync = new Mutex(); + try { + sync.getWaitQueueLength(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + + /** + * getWaitingThreads throws NPE if null + */ + public void testGetWaitingThreadsNPE() { + final Mutex sync = new Mutex(); + try { + sync.getWaitingThreads(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + + /** + * hasWaiters throws IAE if not owned + */ + public void testHasWaitersIAE() { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + final Mutex sync2 = new Mutex(); + try { + sync2.hasWaiters(c); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * hasWaiters throws IMSE if not synced + */ + public void testHasWaitersIMSE() { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + try { + sync.hasWaiters(c); + shouldThrow(); + } catch (IllegalMonitorStateException success) {} + } + + + /** + * getWaitQueueLength throws IAE if not owned + */ + public void testGetWaitQueueLengthIAE() { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + final Mutex sync2 = new Mutex(); + try { + sync2.getWaitQueueLength(c); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * getWaitQueueLength throws IMSE if not synced + */ + public void testGetWaitQueueLengthIMSE() { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + try { + sync.getWaitQueueLength(c); + shouldThrow(); + } catch (IllegalMonitorStateException success) {} + } + + + /** + * getWaitingThreads throws IAE if not owned + */ + public void testGetWaitingThreadsIAE() { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + final Mutex sync2 = new Mutex(); + try { + sync2.getWaitingThreads(c); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * getWaitingThreads throws IMSE if not synced + */ + public void testGetWaitingThreadsIMSE() { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + try { + sync.getWaitingThreads(c); + shouldThrow(); + } catch (IllegalMonitorStateException success) {} + } + + + + /** + * hasWaiters returns true when a thread is waiting, else false + */ + public void testHasWaiters() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + Thread t = new Thread(new Runnable() { + public void run() { + try { + sync.acquire(1); + threadAssertFalse(sync.hasWaiters(c)); + threadAssertEquals(0, sync.getWaitQueueLength(c)); + c.await(); + sync.release(1); + } + catch (InterruptedException e) { + threadUnexpectedException(); + } + } + }); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertTrue(sync.hasWaiters(c)); + assertEquals(1, sync.getWaitQueueLength(c)); + c.signal(); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertFalse(sync.hasWaiters(c)); + assertEquals(0, sync.getWaitQueueLength(c)); + sync.release(1); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); + } + + /** + * getWaitQueueLength returns number of waiting threads + */ + public void testGetWaitQueueLength() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + Thread t1 = new Thread(new Runnable() { + public void run() { + try { + sync.acquire(1); + threadAssertFalse(sync.hasWaiters(c)); + threadAssertEquals(0, sync.getWaitQueueLength(c)); + c.await(); + sync.release(1); + } + catch (InterruptedException e) { + threadUnexpectedException(); + } + } + }); + + Thread t2 = new Thread(new Runnable() { + public void run() { + try { + sync.acquire(1); + threadAssertTrue(sync.hasWaiters(c)); + threadAssertEquals(1, sync.getWaitQueueLength(c)); + c.await(); + sync.release(1); + } + catch (InterruptedException e) { + threadUnexpectedException(); + } + } + }); + + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertTrue(sync.hasWaiters(c)); + assertEquals(2, sync.getWaitQueueLength(c)); + c.signalAll(); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertFalse(sync.hasWaiters(c)); + assertEquals(0, sync.getWaitQueueLength(c)); + sync.release(1); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); + } + + /** + * getWaitingThreads returns only and all waiting threads + */ + public void testGetWaitingThreads() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + Thread t1 = new Thread(new Runnable() { + public void run() { + try { + sync.acquire(1); + threadAssertTrue(sync.getWaitingThreads(c).isEmpty()); + c.await(); + sync.release(1); + } + catch (InterruptedException e) { + threadUnexpectedException(); + } + } + }); + + Thread t2 = new Thread(new Runnable() { + public void run() { + try { + sync.acquire(1); + threadAssertFalse(sync.getWaitingThreads(c).isEmpty()); + c.await(); + sync.release(1); + } + catch (InterruptedException e) { + threadUnexpectedException(); + } + } + }); + + sync.acquire(1); + assertTrue(sync.getWaitingThreads(c).isEmpty()); + sync.release(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertTrue(sync.hasWaiters(c)); + assertTrue(sync.getWaitingThreads(c).contains(t1)); + assertTrue(sync.getWaitingThreads(c).contains(t2)); + c.signalAll(); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertFalse(sync.hasWaiters(c)); + assertTrue(sync.getWaitingThreads(c).isEmpty()); + sync.release(1); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); } + /** - * Latch isSignalled initially returns false, then true after release + * 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 Runnable() { + public void run() { + 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 testLatchIsSignalled() { + public void testAwait_Interrupt() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + Thread t = new Thread(new Runnable() { + public void run() { + try { + sync.acquire(1); + c.await(); + sync.release(1); + threadShouldThrow(); + } + catch (InterruptedException success) { + } + } + }); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); + } + + /** + * awaitNanos is interruptible + */ + public void testAwaitNanos_Interrupt() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + Thread t = new Thread(new Runnable() { + public void run() { + try { + sync.acquire(1); + c.awaitNanos(1000 * 1000 * 1000); // 1 sec + sync.release(1); + threadShouldThrow(); + } + catch (InterruptedException success) { + } + } + }); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); + } + + /** + * awaitUntil is interruptible + */ + public void testAwaitUntil_Interrupt() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + Thread t = new Thread(new Runnable() { + public void run() { + try { + sync.acquire(1); + java.util.Date d = new java.util.Date(); + c.awaitUntil(new java.util.Date(d.getTime() + 10000)); + sync.release(1); + threadShouldThrow(); + } + catch (InterruptedException success) { + } + } + }); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); + } + + /** + * signalAll wakes up all threads + */ + public void testSignalAll() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + Thread t1 = new Thread(new Runnable() { + public void run() { + try { + sync.acquire(1); + c.await(); + sync.release(1); + } + catch (InterruptedException e) { + threadUnexpectedException(); + } + } + }); + + Thread t2 = new Thread(new Runnable() { + public void run() { + try { + sync.acquire(1); + c.await(); + sync.release(1); + } + catch (InterruptedException e) { + threadUnexpectedException(); + } + } + }); + + t1.start(); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + c.signalAll(); + sync.release(1); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); + } + + + /** + * toString indicates current state + */ + public void testToString() { + Mutex sync = new Mutex(); + String us = sync.toString(); + assertTrue(us.indexOf("State = 0") >= 0); + sync.acquire(1); + String ls = sync.toString(); + assertTrue(ls.indexOf("State = 1") >= 0); + } + + /** + * A serialized AQS deserializes with current state + */ + public void testSerialization() throws Exception { + Mutex l = new Mutex(); + l.acquire(1); + assertTrue(l.isHeldExclusively()); + + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + 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()); + } + + + /** + * tryReleaseShared setting state changes getState + */ + public void testGetStateWithReleaseShared() { final BooleanLatch l = new BooleanLatch(); assertFalse(l.isSignalled()); l.releaseShared(0); @@ -532,9 +1001,9 @@ public class AbstractQueuedSynchronizerT } /** - * release and has no effect when already signalled + * releaseShared has no effect when already signalled */ - public void testLatchBoolean() { + public void testReleaseShared() { final BooleanLatch l = new BooleanLatch(); assertFalse(l.isSignalled()); l.releaseShared(0); @@ -546,7 +1015,7 @@ public class AbstractQueuedSynchronizerT /** * acquireSharedInterruptibly returns after release, but not before */ - public void testLatchAcquireSharedInterruptibly() { + public void testAcquireSharedInterruptibly() throws InterruptedException { final BooleanLatch l = new BooleanLatch(); Thread t = new Thread(new Runnable() { @@ -555,58 +1024,52 @@ public class AbstractQueuedSynchronizerT threadAssertFalse(l.isSignalled()); l.acquireSharedInterruptibly(0); threadAssertTrue(l.isSignalled()); - } catch(InterruptedException e){ + } catch (InterruptedException e) { threadUnexpectedException(); } } }); - try { - t.start(); - assertFalse(l.isSignalled()); - Thread.sleep(SHORT_DELAY_MS); - l.releaseShared(0); - assertTrue(l.isSignalled()); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + + t.start(); + assertFalse(l.isSignalled()); + Thread.sleep(SHORT_DELAY_MS); + l.releaseShared(0); + assertTrue(l.isSignalled()); + t.join(); } - + /** * acquireSharedTimed returns after release */ - public void testLatchTimedacquireSharedInterruptibly() { + public void testAsquireSharedTimed() throws InterruptedException { final BooleanLatch l = new BooleanLatch(); Thread t = new Thread(new Runnable() { public void run() { try { threadAssertFalse(l.isSignalled()); - threadAssertTrue(l.acquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000)); + threadAssertTrue(l.tryAcquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000)); threadAssertTrue(l.isSignalled()); - } catch(InterruptedException e){ + } catch (InterruptedException e) { threadUnexpectedException(); } } }); - try { - t.start(); - assertFalse(l.isSignalled()); - Thread.sleep(SHORT_DELAY_MS); - l.releaseShared(0); - assertTrue(l.isSignalled()); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + + t.start(); + assertFalse(l.isSignalled()); + Thread.sleep(SHORT_DELAY_MS); + l.releaseShared(0); + assertTrue(l.isSignalled()); + t.join(); } - + /** * acquireSharedInterruptibly throws IE if interrupted before released */ - public void testLatchAcquireSharedInterruptibly_InterruptedException() { + public void testAcquireSharedInterruptibly_InterruptedException() throws InterruptedException { final BooleanLatch l = new BooleanLatch(); Thread t = new Thread(new Runnable() { public void run() { @@ -614,67 +1077,56 @@ public class AbstractQueuedSynchronizerT threadAssertFalse(l.isSignalled()); l.acquireSharedInterruptibly(0); threadShouldThrow(); - } catch(InterruptedException success){} + } catch (InterruptedException success) {} } }); t.start(); - try { - assertFalse(l.isSignalled()); - t.interrupt(); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + assertFalse(l.isSignalled()); + t.interrupt(); + t.join(); } /** * acquireSharedTimed throws IE if interrupted before released */ - public void testLatchTimedAwait_InterruptedException() { + public void testAcquireSharedNanos_InterruptedException() throws InterruptedException { final BooleanLatch l = new BooleanLatch(); Thread t = new Thread(new Runnable() { public void run() { try { threadAssertFalse(l.isSignalled()); - l.acquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000); - threadShouldThrow(); - } catch(InterruptedException success){} + l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000); + threadShouldThrow(); + } catch (InterruptedException success) {} } }); t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - assertFalse(l.isSignalled()); - t.interrupt(); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + assertFalse(l.isSignalled()); + t.interrupt(); + t.join(); } /** * acquireSharedTimed times out if not released before timeout */ - public void testLatchAwaitTimeout() { + public void testAcquireSharedNanos_Timeout() throws InterruptedException { final BooleanLatch l = new BooleanLatch(); Thread t = new Thread(new Runnable() { public void run() { try { threadAssertFalse(l.isSignalled()); - threadAssertFalse(l.acquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000)); - } catch(InterruptedException ie){ + threadAssertFalse(l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000)); + } catch (InterruptedException ie) { threadUnexpectedException(); } } }); t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - assertFalse(l.isSignalled()); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + assertFalse(l.isSignalled()); + t.join(); } - + + }