test/tck/AbstractQueuedSynchronizerTest.java

/*
 * 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. 
 */


import junit.framework.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;
import java.io.*;

public class AbstractQueuedSynchronizerTest extends JSR166TestCase {
    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());
    }
    public static Test suite() {
        return new TestSuite(AbstractQueuedSynchronizerTest.class);
    }

    /**
     * A simple mutex class, from the AbstractQueuedSynchronizer
     * javadoc.  All tests exercise this as a sample user extension.
     * Other methods/features of AbstractQueuedSynchronizerTest are
     * tested implicitly in ReentrantLock, ReentrantReadWriteLock, and
     * Semaphore test classes
     */
    static class Mutex implements Lock, java.io.Serializable {
        private static class Sync extends AbstractQueuedSynchronizer {
            public int acquireExclusiveState(boolean isQueued, int acquires) {
                assert acquires == 1; // Does not use multiple acquires
                return state().compareAndSet(0, 1)? 0 : -1;
            }
            
            public boolean releaseExclusiveState(int releases) {
                state().set(0);
                return true;
            }
            
            public int acquireSharedState(boolean isQueued, int acquires) {
                throw new UnsupportedOperationException();
            }
            
            public boolean releaseSharedState(int releases) {
                throw new UnsupportedOperationException();
            }
            
            public void checkConditionAccess(Thread thread, boolean waiting) {
                if (state().get() == 0) throw new IllegalMonitorStateException();
            }
            
            Condition newCondition() { return new ConditionObject(); }
            
            private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
                s.defaultReadObject();
                state().set(0); // reset to unlocked state
            }
        }
        
        private final Sync sync = new Sync();
        public boolean tryLock() { 
            return sync.acquireExclusiveState(false, 1) >= 0;
        }
        public void lock() { 
            sync.acquireExclusiveUninterruptibly(1);
        }
        public void lockInterruptibly() throws InterruptedException { 
            sync.acquireExclusiveInterruptibly(1);
        }
        public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
            return sync.acquireExclusiveTimed(1, unit.toNanos(timeout));
        }
        public void unlock() { sync.releaseExclusive(1); }
        public Condition newCondition() { return sync.newCondition(); }
        public boolean isLocked() { return sync.state().get() != 0; }
        public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
    }

    /**
     * A runnable calling lockInterruptibly
     */
    class InterruptibleLockRunnable implements Runnable {
        final Mutex lock;
        InterruptibleLockRunnable(Mutex l) { lock = l; }
        public void run() {
            try {
                lock.lockInterruptibly();
            } catch(InterruptedException success){}
        }
    }


    /**
     * A runnable calling lockInterruptibly that expects to be
     * interrupted
     */
    class InterruptedLockRunnable implements Runnable {
        final Mutex lock;
        InterruptedLockRunnable(Mutex l) { lock = l; }
        public void run() {
            try {
                lock.lockInterruptibly();
                threadShouldThrow();
            } catch(InterruptedException success){}
        }
    }
    
    /**
     * locking an unlocked lock succeeds
     */
    public void testLock() { 
        Mutex rl = new Mutex();
        rl.lock();
        assertTrue(rl.isLocked());
        rl.unlock();
    }

    /**
     * trylock on an unlocked lock succeeds
     */
    public void testTryLock() { 
        Mutex rl = new Mutex();
        assertTrue(rl.tryLock());
        assertTrue(rl.isLocked());
        rl.unlock();
    }

    /**
     * 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.lock();
            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.unlock();
            Thread.sleep(SHORT_DELAY_MS);
            assertFalse(lock.hasQueuedThreads());
            t1.join();
            t2.join();
        } catch(Exception e){
            unexpectedException();
        }
    } 

    /**
     * timed trylock is interruptible.
     */
    public void testInterruptedException2() { 
        final Mutex lock = new Mutex();
        lock.lock();
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS);
                        threadShouldThrow();
                    } catch(InterruptedException success){}
                }
            });
        try {
            t.start();
            t.interrupt();
        } catch(Exception e){
            unexpectedException();
        }
    }


    /**
     * Trylock on a locked lock fails
     */
    public void testTryLockWhenLocked() { 
        final Mutex lock = new Mutex();
        lock.lock();
        Thread t = new Thread(new Runnable() {
                public void run() {
                    threadAssertFalse(lock.tryLock());
                }
            });
        try {
            t.start();
            t.join();
            lock.unlock();
        } catch(Exception e){
            unexpectedException();
        }
    } 

    /**
     * Timed trylock on a locked lock times out
     */
    public void testTryLock_Timeout() { 
        final Mutex lock = new Mutex();
        lock.lock();
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        threadAssertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS));
                    } catch (Exception ex) {
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t.start();
            t.join();
            lock.unlock();
        } catch(Exception e){
            unexpectedException();
        }
    } 
    
   
    /**
     * isLocked is true when locked and false when not
     */
    public void testIsLocked() {
        final Mutex lock = new Mutex();
        lock.lock();
        assertTrue(lock.isLocked());
        lock.unlock();
        assertFalse(lock.isLocked());
        Thread t = new Thread(new Runnable() { 
                public void run() {
                    lock.lock();
                    try {
                        Thread.sleep(SMALL_DELAY_MS);
                    }
                    catch(Exception e) {
                        threadUnexpectedException();
                    }
                    lock.unlock();
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.isLocked());
            t.join();
            assertFalse(lock.isLocked());
        } catch(Exception e){
            unexpectedException();
        }
    }


    /**
     * lockInterruptibly is interruptible.
     */
    public void testLockInterruptibly1() { 
        final Mutex lock = new Mutex();
        lock.lock();
        Thread t = new Thread(new InterruptedLockRunnable(lock));
        try {
            t.start();
            t.interrupt();
            lock.unlock();
            t.join();
        } catch(Exception e){
            unexpectedException();
        }
    } 

    /**
     * lockInterruptibly succeeds when unlocked, else is interruptible
     */
    public void testLockInterruptibly2() {
        final Mutex lock = new Mutex(); 
        try {
            lock.lockInterruptibly();
        } 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();
        }
    }

    /**
     * Calling await without holding lock throws IllegalMonitorStateException
     */
    public void testAwait_IllegalMonitor() {
        final Mutex lock = new Mutex(); 
        final Condition c = lock.newCondition();
        try {
            c.await();
            shouldThrow();
        }
        catch (IllegalMonitorStateException success) {
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * Calling signal without holding lock throws IllegalMonitorStateException
     */
    public void testSignal_IllegalMonitor() {
        final Mutex lock = new Mutex(); 
        final Condition c = lock.newCondition();
        try {
            c.signal();
            shouldThrow();
        }
        catch (IllegalMonitorStateException success) {
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * awaitNanos without a signal times out
     */
    public void testAwaitNanos_Timeout() {
        final Mutex lock = new Mutex(); 
        final Condition c = lock.newCondition();
        try {
            lock.lock();
            long t = c.awaitNanos(100);
            assertTrue(t <= 0);
            lock.unlock();
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     *  timed await without a signal times out
     */
    public void testAwait_Timeout() {
        final Mutex lock = new Mutex(); 
        final Condition c = lock.newCondition();
        try {
            lock.lock();
            assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            lock.unlock();
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * awaitUntil without a signal times out
     */
    public void testAwaitUntil_Timeout() {
        final Mutex lock = new Mutex(); 
        final Condition c = lock.newCondition();
        try {
            lock.lock();
            java.util.Date d = new java.util.Date();
            assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
            lock.unlock();
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * 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 run() {
                    try {
                        lock.lock();
                        c.await();
                        lock.unlock();
                    }
                    catch(InterruptedException e) {
                        threadUnexpectedException();
                    }
                }
            });

        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            lock.lock();
            c.signal();
            lock.unlock();
            t.join(SHORT_DELAY_MS);
            assertFalse(t.isAlive());
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }
    
}
Revision:	1.3
Committed:	Mon Dec 29 14:19:27 2003 UTC (20 years, 4 months ago) by dl
Branch:	MAIN
Changes since 1.2:	+4 -4 lines
Log Message:	Simplify AQS hook methods
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4			* http://creativecommons.org/licenses/publicdomain
5			* Other contributors include Andrew Wright, Jeffrey Hayes,
6			* Pat Fisher, Mike Judd.
7			*/
8
9
10			import junit.framework.*;
11			import java.util.*;
12			import java.util.concurrent.*;
13			import java.util.concurrent.locks.*;
14			import java.io.*;
15
16			public class AbstractQueuedSynchronizerTest extends JSR166TestCase {
17			public static void main(String[] args) {
18			junit.textui.TestRunner.run (suite());
19			}
20			public static Test suite() {
21			return new TestSuite(AbstractQueuedSynchronizerTest.class);
22			}
23
24			/**
25			* A simple mutex class, from the AbstractQueuedSynchronizer
26			* javadoc. All tests exercise this as a sample user extension.
27			* Other methods/features of AbstractQueuedSynchronizerTest are
28			* tested implicitly in ReentrantLock, ReentrantReadWriteLock, and
29			* Semaphore test classes
30			*/
31			static class Mutex implements Lock, java.io.Serializable {
32			private static class Sync extends AbstractQueuedSynchronizer {
33	dl	1.3	public int acquireExclusiveState(boolean isQueued, int acquires) {
34	dl	1.1	assert acquires == 1; // Does not use multiple acquires
35			return state().compareAndSet(0, 1)? 0 : -1;
36			}
37
38			public boolean releaseExclusiveState(int releases) {
39			state().set(0);
40			return true;
41			}
42
43	dl	1.3	public int acquireSharedState(boolean isQueued, int acquires) {
44	dl	1.1	throw new UnsupportedOperationException();
45			}
46
47			public boolean releaseSharedState(int releases) {
48			throw new UnsupportedOperationException();
49			}
50
51			public void checkConditionAccess(Thread thread, boolean waiting) {
52			if (state().get() == 0) throw new IllegalMonitorStateException();
53			}
54
55			Condition newCondition() { return new ConditionObject(); }
56
57			private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
58			s.defaultReadObject();
59			state().set(0); // reset to unlocked state
60			}
61			}
62
63			private final Sync sync = new Sync();
64			public boolean tryLock() {
65	dl	1.3	return sync.acquireExclusiveState(false, 1) >= 0;
66	dl	1.2	}
67			public void lock() {
68	dl	1.3	sync.acquireExclusiveUninterruptibly(1);
69	dl	1.1	}
70			public void lockInterruptibly() throws InterruptedException {
71			sync.acquireExclusiveInterruptibly(1);
72			}
73			public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
74			return sync.acquireExclusiveTimed(1, unit.toNanos(timeout));
75			}
76			public void unlock() { sync.releaseExclusive(1); }
77			public Condition newCondition() { return sync.newCondition(); }
78			public boolean isLocked() { return sync.state().get() != 0; }
79			public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
80			}
81
82			/**
83			* A runnable calling lockInterruptibly
84			*/
85			class InterruptibleLockRunnable implements Runnable {
86			final Mutex lock;
87			InterruptibleLockRunnable(Mutex l) { lock = l; }
88			public void run() {
89			try {
90			lock.lockInterruptibly();
91			} catch(InterruptedException success){}
92			}
93			}
94
95
96			/**
97			* A runnable calling lockInterruptibly that expects to be
98			* interrupted
99			*/
100			class InterruptedLockRunnable implements Runnable {
101			final Mutex lock;
102			InterruptedLockRunnable(Mutex l) { lock = l; }
103			public void run() {
104			try {
105			lock.lockInterruptibly();
106			threadShouldThrow();
107			} catch(InterruptedException success){}
108			}
109			}
110
111			/**
112			* locking an unlocked lock succeeds
113			*/
114			public void testLock() {
115			Mutex rl = new Mutex();
116			rl.lock();
117			assertTrue(rl.isLocked());
118			rl.unlock();
119			}
120
121			/**
122			* trylock on an unlocked lock succeeds
123			*/
124			public void testTryLock() {
125			Mutex rl = new Mutex();
126			assertTrue(rl.tryLock());
127			assertTrue(rl.isLocked());
128			rl.unlock();
129			}
130
131			/**
132			* hasQueuedThreads reports whether there are waiting threads
133			*/
134			public void testhasQueuedThreads() {
135			final Mutex lock = new Mutex();
136			Thread t1 = new Thread(new InterruptedLockRunnable(lock));
137			Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
138			try {
139			assertFalse(lock.hasQueuedThreads());
140			lock.lock();
141			t1.start();
142			Thread.sleep(SHORT_DELAY_MS);
143			assertTrue(lock.hasQueuedThreads());
144			t2.start();
145			Thread.sleep(SHORT_DELAY_MS);
146			assertTrue(lock.hasQueuedThreads());
147			t1.interrupt();
148			Thread.sleep(SHORT_DELAY_MS);
149			assertTrue(lock.hasQueuedThreads());
150			lock.unlock();
151			Thread.sleep(SHORT_DELAY_MS);
152			assertFalse(lock.hasQueuedThreads());
153			t1.join();
154			t2.join();
155			} catch(Exception e){
156			unexpectedException();
157			}
158			}
159
160			/**
161			* timed trylock is interruptible.
162			*/
163			public void testInterruptedException2() {
164			final Mutex lock = new Mutex();
165			lock.lock();
166			Thread t = new Thread(new Runnable() {
167			public void run() {
168			try {
169			lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS);
170			threadShouldThrow();
171			} catch(InterruptedException success){}
172			}
173			});
174			try {
175			t.start();
176			t.interrupt();
177			} catch(Exception e){
178			unexpectedException();
179			}
180			}
181
182
183			/**
184			* Trylock on a locked lock fails
185			*/
186			public void testTryLockWhenLocked() {
187			final Mutex lock = new Mutex();
188			lock.lock();
189			Thread t = new Thread(new Runnable() {
190			public void run() {
191			threadAssertFalse(lock.tryLock());
192			}
193			});
194			try {
195			t.start();
196			t.join();
197			lock.unlock();
198			} catch(Exception e){
199			unexpectedException();
200			}
201			}
202
203			/**
204			* Timed trylock on a locked lock times out
205			*/
206			public void testTryLock_Timeout() {
207			final Mutex lock = new Mutex();
208			lock.lock();
209			Thread t = new Thread(new Runnable() {
210			public void run() {
211			try {
212			threadAssertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS));
213			} catch (Exception ex) {
214			threadUnexpectedException();
215			}
216			}
217			});
218			try {
219			t.start();
220			t.join();
221			lock.unlock();
222			} catch(Exception e){
223			unexpectedException();
224			}
225			}
226
227
228			/**
229			* isLocked is true when locked and false when not
230			*/
231			public void testIsLocked() {
232			final Mutex lock = new Mutex();
233			lock.lock();
234			assertTrue(lock.isLocked());
235			lock.unlock();
236			assertFalse(lock.isLocked());
237			Thread t = new Thread(new Runnable() {
238			public void run() {
239			lock.lock();
240			try {
241			Thread.sleep(SMALL_DELAY_MS);
242			}
243			catch(Exception e) {
244			threadUnexpectedException();
245			}
246			lock.unlock();
247			}
248			});
249			try {
250			t.start();
251			Thread.sleep(SHORT_DELAY_MS);
252			assertTrue(lock.isLocked());
253			t.join();
254			assertFalse(lock.isLocked());
255			} catch(Exception e){
256			unexpectedException();
257			}
258			}
259
260
261			/**
262			* lockInterruptibly is interruptible.
263			*/
264			public void testLockInterruptibly1() {
265			final Mutex lock = new Mutex();
266			lock.lock();
267			Thread t = new Thread(new InterruptedLockRunnable(lock));
268			try {
269			t.start();
270			t.interrupt();
271			lock.unlock();
272			t.join();
273			} catch(Exception e){
274			unexpectedException();
275			}
276			}
277
278			/**
279			* lockInterruptibly succeeds when unlocked, else is interruptible
280			*/
281			public void testLockInterruptibly2() {
282			final Mutex lock = new Mutex();
283			try {
284			lock.lockInterruptibly();
285			} catch(Exception e) {
286			unexpectedException();
287			}
288			Thread t = new Thread(new InterruptedLockRunnable(lock));
289			try {
290			t.start();
291			t.interrupt();
292			assertTrue(lock.isLocked());
293			t.join();
294			} catch(Exception e){
295			unexpectedException();
296			}
297			}
298
299			/**
300			* Calling await without holding lock throws IllegalMonitorStateException
301			*/
302			public void testAwait_IllegalMonitor() {
303			final Mutex lock = new Mutex();
304			final Condition c = lock.newCondition();
305			try {
306			c.await();
307			shouldThrow();
308			}
309			catch (IllegalMonitorStateException success) {
310			}
311			catch (Exception ex) {
312			unexpectedException();
313			}
314			}
315
316			/**
317			* Calling signal without holding lock throws IllegalMonitorStateException
318			*/
319			public void testSignal_IllegalMonitor() {
320			final Mutex lock = new Mutex();
321			final Condition c = lock.newCondition();
322			try {
323			c.signal();
324			shouldThrow();
325			}
326			catch (IllegalMonitorStateException success) {
327			}
328			catch (Exception ex) {
329			unexpectedException();
330			}
331			}
332
333			/**
334			* awaitNanos without a signal times out
335			*/
336			public void testAwaitNanos_Timeout() {
337			final Mutex lock = new Mutex();
338			final Condition c = lock.newCondition();
339			try {
340			lock.lock();
341			long t = c.awaitNanos(100);
342			assertTrue(t <= 0);
343			lock.unlock();
344			}
345			catch (Exception ex) {
346			unexpectedException();
347			}
348			}
349
350			/**
351			* timed await without a signal times out
352			*/
353			public void testAwait_Timeout() {
354			final Mutex lock = new Mutex();
355			final Condition c = lock.newCondition();
356			try {
357			lock.lock();
358			assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
359			lock.unlock();
360			}
361			catch (Exception ex) {
362			unexpectedException();
363			}
364			}
365
366			/**
367			* awaitUntil without a signal times out
368			*/
369			public void testAwaitUntil_Timeout() {
370			final Mutex lock = new Mutex();
371			final Condition c = lock.newCondition();
372			try {
373			lock.lock();
374			java.util.Date d = new java.util.Date();
375			assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
376			lock.unlock();
377			}
378			catch (Exception ex) {
379			unexpectedException();
380			}
381			}
382
383			/**
384			* await returns when signalled
385			*/
386			public void testAwait() {
387			final Mutex lock = new Mutex();
388			final Condition c = lock.newCondition();
389			Thread t = new Thread(new Runnable() {
390			public void run() {
391			try {
392			lock.lock();
393			c.await();
394			lock.unlock();
395			}
396			catch(InterruptedException e) {
397			threadUnexpectedException();
398			}
399			}
400			});
401
402			try {
403			t.start();
404			Thread.sleep(SHORT_DELAY_MS);
405			lock.lock();
406			c.signal();
407			lock.unlock();
408			t.join(SHORT_DELAY_MS);
409			assertFalse(t.isAlive());
410			}
411			catch (Exception ex) {
412			unexpectedException();
413			}
414			}
415
416			}