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 {
            boolean isLocked() { return getState() == 1; }

            public boolean tryAcquireExclusive(boolean isQueued, int acquires) {
                assert acquires == 1; // Does not use multiple acquires
                return compareAndSetState(0, 1);
            }
            
            public boolean tryReleaseExclusive(int releases) {
                setState(0);
                return true;
            }
            
            public void checkConditionAccess(Thread thread, boolean waiting) {
                if (getState() == 0) throw new IllegalMonitorStateException();
            }
            
            Condition newCondition() { return new ConditionObject(); }
            
            private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
                s.defaultReadObject();
                setState(0); // reset to unlocked state
            }
        }
         
        private final Sync sync = new Sync();
        public boolean tryLock() { 
            return sync.tryAcquireExclusive(false, 1);
        }
        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.isLocked(); }
        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.7
Committed:	Fri Jan 2 21:06:38 2004 UTC (20 years, 4 months ago) by dl
Branch:	MAIN
Changes since 1.6:	+4 -4 lines
Log Message:	Use new AQS 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.6	boolean isLocked() { return getState() == 1; }
34
35	dl	1.7	public boolean tryAcquireExclusive(boolean isQueued, int acquires) {
36	dl	1.1	assert acquires == 1; // Does not use multiple acquires
37	dl	1.6	return compareAndSetState(0, 1);
38	dl	1.1	}
39
40	dl	1.7	public boolean tryReleaseExclusive(int releases) {
41	dl	1.6	setState(0);
42	dl	1.1	return true;
43			}
44
45			public void checkConditionAccess(Thread thread, boolean waiting) {
46	dl	1.6	if (getState() == 0) throw new IllegalMonitorStateException();
47	dl	1.1	}
48
49			Condition newCondition() { return new ConditionObject(); }
50
51			private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
52			s.defaultReadObject();
53	dl	1.6	setState(0); // reset to unlocked state
54	dl	1.1	}
55			}
56	dl	1.7
57	dl	1.1	private final Sync sync = new Sync();
58			public boolean tryLock() {
59	dl	1.7	return sync.tryAcquireExclusive(false, 1);
60	dl	1.2	}
61			public void lock() {
62	dl	1.3	sync.acquireExclusiveUninterruptibly(1);
63	dl	1.1	}
64			public void lockInterruptibly() throws InterruptedException {
65			sync.acquireExclusiveInterruptibly(1);
66			}
67			public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
68			return sync.acquireExclusiveTimed(1, unit.toNanos(timeout));
69			}
70			public void unlock() { sync.releaseExclusive(1); }
71			public Condition newCondition() { return sync.newCondition(); }
72	dl	1.6	public boolean isLocked() { return sync.isLocked(); }
73	dl	1.1	public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
74			}
75
76			/**
77			* A runnable calling lockInterruptibly
78			*/
79			class InterruptibleLockRunnable implements Runnable {
80			final Mutex lock;
81			InterruptibleLockRunnable(Mutex l) { lock = l; }
82			public void run() {
83			try {
84			lock.lockInterruptibly();
85			} catch(InterruptedException success){}
86			}
87			}
88
89
90			/**
91			* A runnable calling lockInterruptibly that expects to be
92			* interrupted
93			*/
94			class InterruptedLockRunnable implements Runnable {
95			final Mutex lock;
96			InterruptedLockRunnable(Mutex l) { lock = l; }
97			public void run() {
98			try {
99			lock.lockInterruptibly();
100			threadShouldThrow();
101			} catch(InterruptedException success){}
102			}
103			}
104
105			/**
106			* locking an unlocked lock succeeds
107			*/
108			public void testLock() {
109			Mutex rl = new Mutex();
110			rl.lock();
111			assertTrue(rl.isLocked());
112			rl.unlock();
113			}
114
115			/**
116	dl	1.4	* tryLock on an unlocked lock succeeds
117	dl	1.1	*/
118			public void testTryLock() {
119			Mutex rl = new Mutex();
120			assertTrue(rl.tryLock());
121			assertTrue(rl.isLocked());
122			rl.unlock();
123			}
124
125			/**
126			* hasQueuedThreads reports whether there are waiting threads
127			*/
128			public void testhasQueuedThreads() {
129			final Mutex lock = new Mutex();
130			Thread t1 = new Thread(new InterruptedLockRunnable(lock));
131			Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
132			try {
133			assertFalse(lock.hasQueuedThreads());
134			lock.lock();
135			t1.start();
136			Thread.sleep(SHORT_DELAY_MS);
137			assertTrue(lock.hasQueuedThreads());
138			t2.start();
139			Thread.sleep(SHORT_DELAY_MS);
140			assertTrue(lock.hasQueuedThreads());
141			t1.interrupt();
142			Thread.sleep(SHORT_DELAY_MS);
143			assertTrue(lock.hasQueuedThreads());
144			lock.unlock();
145			Thread.sleep(SHORT_DELAY_MS);
146			assertFalse(lock.hasQueuedThreads());
147			t1.join();
148			t2.join();
149			} catch(Exception e){
150			unexpectedException();
151			}
152			}
153
154			/**
155	dl	1.4	* timed tryLock is interruptible.
156	dl	1.1	*/
157			public void testInterruptedException2() {
158			final Mutex lock = new Mutex();
159			lock.lock();
160			Thread t = new Thread(new Runnable() {
161			public void run() {
162			try {
163			lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS);
164			threadShouldThrow();
165			} catch(InterruptedException success){}
166			}
167			});
168			try {
169			t.start();
170			t.interrupt();
171			} catch(Exception e){
172			unexpectedException();
173			}
174			}
175
176
177			/**
178	dl	1.4	* TryLock on a locked lock fails
179	dl	1.1	*/
180			public void testTryLockWhenLocked() {
181			final Mutex lock = new Mutex();
182			lock.lock();
183			Thread t = new Thread(new Runnable() {
184			public void run() {
185			threadAssertFalse(lock.tryLock());
186			}
187			});
188			try {
189			t.start();
190			t.join();
191			lock.unlock();
192			} catch(Exception e){
193			unexpectedException();
194			}
195			}
196
197			/**
198	dl	1.4	* Timed tryLock on a locked lock times out
199	dl	1.1	*/
200			public void testTryLock_Timeout() {
201			final Mutex lock = new Mutex();
202			lock.lock();
203			Thread t = new Thread(new Runnable() {
204			public void run() {
205			try {
206			threadAssertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS));
207			} catch (Exception ex) {
208			threadUnexpectedException();
209			}
210			}
211			});
212			try {
213			t.start();
214			t.join();
215			lock.unlock();
216			} catch(Exception e){
217			unexpectedException();
218			}
219			}
220
221
222			/**
223			* isLocked is true when locked and false when not
224			*/
225			public void testIsLocked() {
226			final Mutex lock = new Mutex();
227			lock.lock();
228			assertTrue(lock.isLocked());
229			lock.unlock();
230			assertFalse(lock.isLocked());
231			Thread t = new Thread(new Runnable() {
232			public void run() {
233			lock.lock();
234			try {
235			Thread.sleep(SMALL_DELAY_MS);
236			}
237			catch(Exception e) {
238			threadUnexpectedException();
239			}
240			lock.unlock();
241			}
242			});
243			try {
244			t.start();
245			Thread.sleep(SHORT_DELAY_MS);
246			assertTrue(lock.isLocked());
247			t.join();
248			assertFalse(lock.isLocked());
249			} catch(Exception e){
250			unexpectedException();
251			}
252			}
253
254
255			/**
256			* lockInterruptibly is interruptible.
257			*/
258			public void testLockInterruptibly1() {
259			final Mutex lock = new Mutex();
260			lock.lock();
261			Thread t = new Thread(new InterruptedLockRunnable(lock));
262			try {
263			t.start();
264			t.interrupt();
265			lock.unlock();
266			t.join();
267			} catch(Exception e){
268			unexpectedException();
269			}
270			}
271
272			/**
273			* lockInterruptibly succeeds when unlocked, else is interruptible
274			*/
275			public void testLockInterruptibly2() {
276			final Mutex lock = new Mutex();
277			try {
278			lock.lockInterruptibly();
279			} catch(Exception e) {
280			unexpectedException();
281			}
282			Thread t = new Thread(new InterruptedLockRunnable(lock));
283			try {
284			t.start();
285			t.interrupt();
286			assertTrue(lock.isLocked());
287			t.join();
288			} catch(Exception e){
289			unexpectedException();
290			}
291			}
292
293			/**
294			* Calling await without holding lock throws IllegalMonitorStateException
295			*/
296			public void testAwait_IllegalMonitor() {
297			final Mutex lock = new Mutex();
298			final Condition c = lock.newCondition();
299			try {
300			c.await();
301			shouldThrow();
302			}
303			catch (IllegalMonitorStateException success) {
304			}
305			catch (Exception ex) {
306			unexpectedException();
307			}
308			}
309
310			/**
311			* Calling signal without holding lock throws IllegalMonitorStateException
312			*/
313			public void testSignal_IllegalMonitor() {
314			final Mutex lock = new Mutex();
315			final Condition c = lock.newCondition();
316			try {
317			c.signal();
318			shouldThrow();
319			}
320			catch (IllegalMonitorStateException success) {
321			}
322			catch (Exception ex) {
323			unexpectedException();
324			}
325			}
326
327			/**
328			* awaitNanos without a signal times out
329			*/
330			public void testAwaitNanos_Timeout() {
331			final Mutex lock = new Mutex();
332			final Condition c = lock.newCondition();
333			try {
334			lock.lock();
335			long t = c.awaitNanos(100);
336			assertTrue(t <= 0);
337			lock.unlock();
338			}
339			catch (Exception ex) {
340			unexpectedException();
341			}
342			}
343
344			/**
345			* timed await without a signal times out
346			*/
347			public void testAwait_Timeout() {
348			final Mutex lock = new Mutex();
349			final Condition c = lock.newCondition();
350			try {
351			lock.lock();
352			assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
353			lock.unlock();
354			}
355			catch (Exception ex) {
356			unexpectedException();
357			}
358			}
359
360			/**
361			* awaitUntil without a signal times out
362			*/
363			public void testAwaitUntil_Timeout() {
364			final Mutex lock = new Mutex();
365			final Condition c = lock.newCondition();
366			try {
367			lock.lock();
368			java.util.Date d = new java.util.Date();
369			assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
370			lock.unlock();
371			}
372			catch (Exception ex) {
373			unexpectedException();
374			}
375			}
376
377			/**
378			* await returns when signalled
379			*/
380			public void testAwait() {
381			final Mutex lock = new Mutex();
382			final Condition c = lock.newCondition();
383			Thread t = new Thread(new Runnable() {
384			public void run() {
385			try {
386			lock.lock();
387			c.await();
388			lock.unlock();
389			}
390			catch(InterruptedException e) {
391			threadUnexpectedException();
392			}
393			}
394			});
395
396			try {
397			t.start();
398			Thread.sleep(SHORT_DELAY_MS);
399			lock.lock();
400			c.signal();
401			lock.unlock();
402			t.join(SHORT_DELAY_MS);
403			assertFalse(t.isAlive());
404			}
405			catch (Exception ex) {
406			unexpectedException();
407			}
408			}
409
410			}