/** awaitUninterruptibly is uninterruptible */ public void testAwaitUninterruptibly() { final Mutex sync = new Mutex(); final ConditionObject c = sync.newCondition(); final BooleanLatch pleaseInterrupt = new BooleanLatch(); Thread t = newStartedThread( new CheckedRunnable() { public void realRun() { sync.acquire(); assertTrue(pleaseInterrupt.releaseShared(0)); c.awaitUninterruptibly(); assertTrue(Thread.interrupted()); assertHasWaitersLocked(sync, c, NO_THREADS); sync.release(); } }); pleaseInterrupt.acquireShared(0); sync.acquire(); assertHasWaitersLocked(sync, c, t); sync.release(); t.interrupt(); assertHasWaitersUnlocked(sync, c, t); assertThreadStaysAlive(t); sync.acquire(); assertHasWaitersLocked(sync, c, t); assertHasExclusiveQueuedThreads(sync, NO_THREADS); c.signal(); assertHasWaitersLocked(sync, c, NO_THREADS); assertHasExclusiveQueuedThreads(sync, t); sync.release(); awaitTermination(t); }
public void thread3() { waitForTick(2); sync.acquire(1); assertTrue(sync.hasWaiters(c)); assertEquals(2, sync.getWaitQueueLength(c)); c.signalAll(); sync.release(1); waitForTick(3); sync.acquire(1); assertFalse(sync.hasWaiters(c)); assertEquals(0, sync.getWaitQueueLength(c)); sync.release(1); }
/** getWaitQueueLength returns number of waiting threads */ public void testGetWaitQueueLength() { final Mutex sync = new Mutex(); final ConditionObject c = sync.newCondition(); final BooleanLatch acquired1 = new BooleanLatch(); final BooleanLatch acquired2 = new BooleanLatch(); final Thread t1 = newStartedThread( new CheckedRunnable() { public void realRun() throws InterruptedException { sync.acquire(); assertHasWaitersLocked(sync, c, NO_THREADS); assertEquals(0, sync.getWaitQueueLength(c)); assertTrue(acquired1.releaseShared(0)); c.await(); sync.release(); } }); acquired1.acquireShared(0); sync.acquire(); assertHasWaitersLocked(sync, c, t1); assertEquals(1, sync.getWaitQueueLength(c)); sync.release(); final Thread t2 = newStartedThread( new CheckedRunnable() { public void realRun() throws InterruptedException { sync.acquire(); assertHasWaitersLocked(sync, c, t1); assertEquals(1, sync.getWaitQueueLength(c)); assertTrue(acquired2.releaseShared(0)); c.await(); sync.release(); } }); acquired2.acquireShared(0); sync.acquire(); assertHasWaitersLocked(sync, c, t1, t2); assertHasExclusiveQueuedThreads(sync, NO_THREADS); assertEquals(2, sync.getWaitQueueLength(c)); c.signalAll(); assertHasWaitersLocked(sync, c, NO_THREADS); assertHasExclusiveQueuedThreads(sync, t1, t2); assertEquals(0, sync.getWaitQueueLength(c)); sync.release(); awaitTermination(t1); awaitTermination(t2); assertHasWaitersUnlocked(sync, c, NO_THREADS); }
/** tryAcquire on a released sync succeeds */ public void testTryAcquire() { Mutex sync = new Mutex(); assertTrue(sync.tryAcquire()); assertTrue(sync.isHeldExclusively()); sync.release(); assertFalse(sync.isHeldExclusively()); }
public void testAwait_Timeout(AwaitMethod awaitMethod) { final Mutex sync = new Mutex(); final ConditionObject c = sync.newCondition(); sync.acquire(); assertAwaitTimesOut(c, awaitMethod); sync.release(); }
/** getState is true when acquired and false when not */ public void testGetState() { final Mutex sync = new Mutex(); sync.acquire(); assertTrue(sync.isHeldExclusively()); sync.release(); assertFalse(sync.isHeldExclusively()); final BooleanLatch acquired = new BooleanLatch(); final BooleanLatch done = new BooleanLatch(); Thread t = newStartedThread( new CheckedRunnable() { public void realRun() throws InterruptedException { sync.acquire(); assertTrue(acquired.releaseShared(0)); done.acquireShared(0); sync.release(); } }); acquired.acquireShared(0); assertTrue(sync.isHeldExclusively()); assertTrue(done.releaseShared(0)); awaitTermination(t); assertFalse(sync.isHeldExclusively()); }
public void thread2() throws InterruptedException { waitForTick(1); getThread(1).interrupt(); sync.acquire(1); c.signal(); sync.release(1); }
/** hasWaiters returns true when a thread is waiting, else false */ public void testHasWaiters() { final Mutex sync = new Mutex(); final ConditionObject c = sync.newCondition(); final BooleanLatch acquired = new BooleanLatch(); Thread t = newStartedThread( new CheckedRunnable() { public void realRun() throws InterruptedException { sync.acquire(); assertHasWaitersLocked(sync, c, NO_THREADS); assertFalse(sync.hasWaiters(c)); assertTrue(acquired.releaseShared(0)); c.await(); sync.release(); } }); acquired.acquireShared(0); sync.acquire(); assertHasWaitersLocked(sync, c, t); assertHasExclusiveQueuedThreads(sync, NO_THREADS); assertTrue(sync.hasWaiters(c)); c.signal(); assertHasWaitersLocked(sync, c, NO_THREADS); assertHasExclusiveQueuedThreads(sync, t); assertFalse(sync.hasWaiters(c)); sync.release(); awaitTermination(t); assertHasWaitersUnlocked(sync, c, NO_THREADS); }
public void thread2() throws InterruptedException { waitForTick(1); sync.acquire(1); assertTrue(sync.hasWaiters(c)); assertEquals(1, sync.getWaitQueueLength(c)); c.signal(); sync.release(1); waitForTick(2); sync.acquire(1); assertFalse(sync.hasWaiters(c)); assertEquals(0, sync.getWaitQueueLength(c)); sync.release(1); getThread(1).join(SHORT_DELAY_MS); assertFalse(getThread(1).isAlive()); }
public void thread2() throws InterruptedException { waitForTick(1); sync.acquire(1); c.signal(); sync.release(1); getThread(1).join(SHORT_DELAY_MS); assertFalse(getThread(1).isAlive()); }
public void thread1() throws InterruptedException { sync.acquire(1); assertFalse(sync.hasWaiters(c)); assertEquals(0, sync.getWaitQueueLength(c)); c.await(); assertTick(1); sync.release(1); }
public void thread2() throws InterruptedException { waitForTick(2); sync.acquire(1); assertFalse(sync.getWaitingThreads(c).isEmpty()); c.await(); assertTick(3); sync.release(1); }
public void thread2() throws InterruptedException { waitForTick(1); sync.acquire(1); assertTrue(sync.hasWaiters(c)); assertEquals(1, sync.getWaitQueueLength(c)); c.await(); assertTick(2); sync.release(1); }
public void thread0() { waitForTick(1); assertTrue(sync.hasQueuedThreads()); waitForTick(3); assertTrue(sync.hasQueuedThreads()); getThread(1).interrupt(); waitForTick(4); assertTrue(sync.hasQueuedThreads()); sync.release(1); }
public void thread3() { sync.acquire(1); assertTrue(sync.getWaitingThreads(c).isEmpty()); sync.release(1); waitForTick(3); sync.acquire(1); assertTrue(sync.hasWaiters(c)); assertTrue(sync.getWaitingThreads(c).contains(getThread(1))); assertTrue(sync.getWaitingThreads(c).contains(getThread(2))); c.signalAll(); sync.release(1); waitForTick(4); sync.acquire(1); assertFalse(sync.hasWaiters(c)); assertTrue(sync.getWaitingThreads(c).isEmpty()); sync.release(1); }
public void thread1() { try { sync.acquire(1); c.awaitNanos(1000 * 1000 * 1000); // 1 sec sync.release(1); fail("should throw exception"); } catch (InterruptedException success) { assertTick(1); } }
public void thread1() { try { sync.acquire(1); java.util.Date d = new java.util.Date(); c.awaitUntil(new java.util.Date(d.getTime() + 10000)); sync.release(1); fail("should throw exception"); } catch (InterruptedException success) { assertTick(1); } }
public void thread3() { waitForTick(1); assertTrue(sync.getSharedQueuedThreads().isEmpty()); waitForTick(3); assertTrue(sync.getSharedQueuedThreads().isEmpty()); getThread(1).interrupt(); waitForTick(4); assertTrue(sync.getSharedQueuedThreads().isEmpty()); sync.release(1); }
public void thread2() { sync.acquire(1); assertTrue(sync.isHeldExclusively()); sync.release(1); assertFalse(sync.isHeldExclusively()); waitForTick(2); assertTrue(sync.isHeldExclusively()); waitForTick(4); assertFalse(sync.isHeldExclusively()); }
public void thread3() { waitForTick(1); assertTrue(sync.hasContended()); waitForTick(3); assertTrue(sync.hasContended()); getThread(1).interrupt(); waitForTick(4); assertTrue(sync.hasContended()); sync.release(1); }
/** tryAcquire on exclusively held sync fails */ public void testTryAcquireWhenSynced() { final Mutex sync = new Mutex(); sync.acquire(); Thread t = newStartedThread( new CheckedRunnable() { public void realRun() { assertFalse(sync.tryAcquire()); } }); awaitTermination(t); sync.release(); }
public void thread3() { waitForTick(1); assertTrue(sync.getExclusiveQueuedThreads().contains(getThread(1))); waitForTick(3); assertTrue(sync.getExclusiveQueuedThreads().contains(getThread(1))); assertTrue(sync.getExclusiveQueuedThreads().contains(getThread(2))); getThread(1).interrupt(); waitForTick(4); assertFalse(sync.getExclusiveQueuedThreads().contains(getThread(1))); assertTrue(sync.getExclusiveQueuedThreads().contains(getThread(2))); sync.release(1); }
public void thread3() { assertNull(sync.getFirstQueuedThread()); sync.acquire(1); waitForTick(2); assertEquals(getThread(1), sync.getFirstQueuedThread()); waitForTick(4); assertEquals(getThread(1), sync.getFirstQueuedThread()); getThread(1).interrupt(); waitForTick(5); assertEquals(getThread(2), sync.getFirstQueuedThread()); sync.release(1); }
/** hasQueuedThreads reports whether there are waiting threads */ public void testHasQueuedThreads() { final Mutex sync = new Mutex(); assertFalse(sync.hasQueuedThreads()); sync.acquire(); Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync)); waitForQueuedThread(sync, t1); assertTrue(sync.hasQueuedThreads()); Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync)); waitForQueuedThread(sync, t2); assertTrue(sync.hasQueuedThreads()); t1.interrupt(); awaitTermination(t1); assertTrue(sync.hasQueuedThreads()); sync.release(); awaitTermination(t2); assertFalse(sync.hasQueuedThreads()); }
/** getFirstQueuedThread returns first waiting thread or null if none */ public void testGetFirstQueuedThread() { final Mutex sync = new Mutex(); assertNull(sync.getFirstQueuedThread()); sync.acquire(); Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync)); waitForQueuedThread(sync, t1); assertEquals(t1, sync.getFirstQueuedThread()); Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync)); waitForQueuedThread(sync, t2); assertEquals(t1, sync.getFirstQueuedThread()); t1.interrupt(); awaitTermination(t1); assertEquals(t2, sync.getFirstQueuedThread()); sync.release(); awaitTermination(t2); assertNull(sync.getFirstQueuedThread()); }
/** tryAcquireNanos on an exclusively held sync times out */ public void testAcquireNanos_Timeout() { final Mutex sync = new Mutex(); sync.acquire(); Thread t = newStartedThread( new CheckedRunnable() { public void realRun() throws InterruptedException { long startTime = System.nanoTime(); long nanos = MILLISECONDS.toNanos(timeoutMillis()); assertFalse(sync.tryAcquireNanos(nanos)); assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); } }); awaitTermination(t); sync.release(); }
/** getSharedQueuedThreads does not include exclusively waiting threads */ public void testGetSharedQueuedThreads_Exclusive() { final Mutex sync = new Mutex(); assertTrue(sync.getSharedQueuedThreads().isEmpty()); sync.acquire(); assertTrue(sync.getSharedQueuedThreads().isEmpty()); Thread t1 = newStartedThread(new InterruptedSyncRunnable(sync)); waitForQueuedThread(sync, t1); assertTrue(sync.getSharedQueuedThreads().isEmpty()); Thread t2 = newStartedThread(new InterruptibleSyncRunnable(sync)); waitForQueuedThread(sync, t2); assertTrue(sync.getSharedQueuedThreads().isEmpty()); t1.interrupt(); awaitTermination(t1); assertTrue(sync.getSharedQueuedThreads().isEmpty()); sync.release(); awaitTermination(t2); assertTrue(sync.getSharedQueuedThreads().isEmpty()); }
public void thread0() { assertFalse(sync.isQueued(getThread(1))); assertFalse(sync.isQueued(getThread(2))); sync.acquire(1); waitForTick(2); assertTrue(sync.isQueued(getThread(1))); waitForTick(4); assertTrue(sync.isQueued(getThread(1))); assertTrue(sync.isQueued(getThread(2))); getThread(1).interrupt(); waitForTick(5); assertFalse(sync.isQueued(getThread(1))); assertTrue(sync.isQueued(getThread(2))); sync.release(1); }
public void thread3() { assertTrue(sync.getQueuedThreads().isEmpty()); sync.acquire(1); assertTrue(sync.getQueuedThreads().isEmpty()); waitForTick(2); assertTrue(sync.getQueuedThreads().contains(getThread(1))); waitForTick(4); assertTrue(sync.getQueuedThreads().contains(getThread(1))); assertTrue(sync.getQueuedThreads().contains(getThread(2))); getThread(1).interrupt(); waitForTick(5); assertFalse(sync.getQueuedThreads().contains(getThread(1))); assertTrue(sync.getQueuedThreads().contains(getThread(2))); sync.release(1); }
/** A serialized AQS deserializes with current state, but no queued threads */ public void testSerialization() { Mutex sync = new Mutex(); assertFalse(serialClone(sync).isHeldExclusively()); sync.acquire(); Thread t = newStartedThread(new InterruptedSyncRunnable(sync)); waitForQueuedThread(sync, t); assertTrue(sync.isHeldExclusively()); Mutex clone = serialClone(sync); assertTrue(clone.isHeldExclusively()); assertHasExclusiveQueuedThreads(sync, t); assertHasExclusiveQueuedThreads(clone, NO_THREADS); t.interrupt(); awaitTermination(t); sync.release(); assertFalse(sync.isHeldExclusively()); assertTrue(clone.isHeldExclusively()); assertHasExclusiveQueuedThreads(sync, NO_THREADS); assertHasExclusiveQueuedThreads(clone, NO_THREADS); }