test/tck/LockSupportTest.java

/*
 * Written by Doug Lea and Martin Buchholz 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.atomic.AtomicBoolean;
import java.util.concurrent.locks.*;

public class LockSupportTest extends JSR166TestCase {
    public static void main(String[] args) {
        junit.textui.TestRunner.run(suite());
    }

    public static Test suite() {
        return new TestSuite(LockSupportTest.class);
    }

    /**
     * park is released by subsequent unpark
     */
    public void testParkBeforeUnpark() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                threadStarted.countDown();
                LockSupport.park();
            }});

        t.start();
        threadStarted.await();
        Thread.sleep(SHORT_DELAY_MS);
        LockSupport.unpark(t);
        joinWith(t);
    }

    /**
     * parkUntil is released by subsequent unpark
     */
    public void testParkUntilBeforeUnpark() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                long d = new Date().getTime() + LONG_DELAY_MS;
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                threadStarted.countDown();
                LockSupport.parkUntil(d);
                assertTrue(System.nanoTime() - t0 < nanos);
            }});

        t.start();
        threadStarted.await();
        Thread.sleep(SHORT_DELAY_MS);
        LockSupport.unpark(t);
        joinWith(t);
    }

    /**
     * parkNanos is released by subsequent unpark
     */
    public void testParkNanosBeforeUnpark() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                threadStarted.countDown();
                LockSupport.parkNanos(nanos);
                assertTrue(System.nanoTime() - t0 < nanos);
            }});

        t.start();
        threadStarted.await();
        Thread.sleep(SHORT_DELAY_MS);
        LockSupport.unpark(t);
        joinWith(t);
    }

    /**
     * park is released by preceding unpark
     */
    public void testParkAfterUnpark() throws Exception {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final AtomicBoolean unparked = new AtomicBoolean(false);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                while (!unparked.get())
                    Thread.yield();
                LockSupport.park();
            }});

        t.start();
        threadStarted.await();
        LockSupport.unpark(t);
        unparked.set(true);
        joinWith(t);
    }

    /**
     * parkUntil is released by preceding unpark
     */
    public void testParkUntilAfterUnpark() throws Exception {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final AtomicBoolean unparked = new AtomicBoolean(false);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                while (!unparked.get())
                    Thread.yield();
                long d = new Date().getTime() + LONG_DELAY_MS;
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                LockSupport.parkUntil(d);
                assertTrue(System.nanoTime() - t0 < nanos);
            }});

        t.start();
        threadStarted.await();
        LockSupport.unpark(t);
        unparked.set(true);
        joinWith(t);
    }

    /**
     * parkNanos is released by preceding unpark
     */
    public void testParkNanosAfterUnpark() throws Exception {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final AtomicBoolean unparked = new AtomicBoolean(false);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                while (!unparked.get())
                    Thread.yield();
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                LockSupport.parkNanos(nanos);
                assertTrue(System.nanoTime() - t0 < nanos);
            }});

        t.start();
        threadStarted.await();
        LockSupport.unpark(t);
        unparked.set(true);
        joinWith(t);
    }

    /**
     * park is released by subsequent interrupt
     */
    public void testParkBeforeInterrupt() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                assertFalse(Thread.currentThread().isInterrupted());
                threadStarted.countDown();
                LockSupport.park();
                assertTrue(Thread.currentThread().isInterrupted());
            }});

        t.start();
        threadStarted.await();
        Thread.sleep(SHORT_DELAY_MS);
        t.interrupt();
        joinWith(t);
    }

    /**
     * parkUntil is released by subsequent interrupt
     */
    public void testParkUntilBeforeInterrupt() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                long d = new Date().getTime() + LONG_DELAY_MS;
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                threadStarted.countDown();
                LockSupport.parkUntil(d);
                assertTrue(System.nanoTime() - t0 < nanos);
            }});

        t.start();
        threadStarted.await();
        Thread.sleep(SHORT_DELAY_MS);
        t.interrupt();
        joinWith(t);
    }

    /**
     * parkNanos is released by subsequent interrupt
     */
    public void testParkNanosBeforeInterrupt() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                threadStarted.countDown();
                LockSupport.parkNanos(nanos);
                assertTrue(System.nanoTime() - t0 < nanos);
            }});

        t.start();
        threadStarted.await();
        Thread.sleep(SHORT_DELAY_MS);
        t.interrupt();
        joinWith(t);
    }

    /**
     * park is released by preceding interrupt
     */
    public void testParkAfterInterrupt() throws Exception {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final AtomicBoolean unparked = new AtomicBoolean(false);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                while (!unparked.get())
                    Thread.yield();
                assertTrue(Thread.currentThread().isInterrupted());
                LockSupport.park();
                assertTrue(Thread.currentThread().isInterrupted());
            }});

        t.start();
        threadStarted.await();
        t.interrupt();
        unparked.set(true);
        joinWith(t);
    }

    /**
     * parkUntil is released by preceding interrupt
     */
    public void testParkUntilAfterInterrupt() throws Exception {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final AtomicBoolean unparked = new AtomicBoolean(false);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                while (!unparked.get())
                    Thread.yield();
                long d = new Date().getTime() + LONG_DELAY_MS;
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                LockSupport.parkUntil(d);
                assertTrue(System.nanoTime() - t0 < nanos);
            }});

        t.start();
        threadStarted.await();
        t.interrupt();
        unparked.set(true);
        joinWith(t);
    }

    /**
     * parkNanos is released by preceding interrupt
     */
    public void testParkNanosAfterInterrupt() throws Exception {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final AtomicBoolean unparked = new AtomicBoolean(false);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                while (!unparked.get())
                    Thread.yield();
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                LockSupport.parkNanos(nanos);
                assertTrue(System.nanoTime() - t0 < nanos);
            }});

        t.start();
        threadStarted.await();
        t.interrupt();
        unparked.set(true);
        joinWith(t);
    }

    /**
     * parkNanos times out if not unparked
     */
    public void testParkNanosTimesOut() throws InterruptedException {
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                LockSupport.parkNanos(timeoutNanos);
                assertTrue(System.nanoTime() - t0 >= timeoutNanos);
            }});

        t.start();
        joinWith(t);
    }


    /**
     * parkUntil times out if not unparked
     */
    public void testParkUntilTimesOut() throws InterruptedException {
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                long d = new Date().getTime() + SHORT_DELAY_MS;
                // beware of rounding
                long timeoutNanos = (SHORT_DELAY_MS - 1) * 1000L * 1000L;
                long t0 = System.nanoTime();
                LockSupport.parkUntil(d);
                assertTrue(System.nanoTime() - t0 >= timeoutNanos);
            }});

        t.start();
        joinWith(t);
    }

    /**
     * parkUntil(0) returns immediately
     * Requires hotspot fix for:
     * 6763959 java.util.concurrent.locks.LockSupport.parkUntil(0) blocks forever
     */
    public void XXXtestParkUntil0Returns() throws InterruptedException {
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                LockSupport.parkUntil(0L);
            }});

        t.start();
        joinWith(t);
    }

    private void joinWith(Thread t) throws InterruptedException {
        t.join(MEDIUM_DELAY_MS);
        if (t.isAlive()) {
            fail("Test timed out");
            t.interrupt();
        }
    }
}
Revision:	1.15
Committed:	Mon Oct 4 20:15:16 2010 UTC (13 years, 7 months ago) by jsr166
Branch:	MAIN
Changes since 1.14:	+262 -27 lines
Log Message:	Add (disabled) test XXXtestParkUntil0Returns; rewrite using better infrastructure; add more tests
#	Content
1	/*
2	* Written by Doug Lea and Martin Buchholz with assistance from
3	* members of JCP JSR-166 Expert Group and released to the public
4	* domain, as explained at
5	* http://creativecommons.org/licenses/publicdomain
6	* Other contributors include Andrew Wright, Jeffrey Hayes,
7	* Pat Fisher, Mike Judd.
8	*/
9
10	import junit.framework.*;
11	import java.util.*;
12	import java.util.concurrent.*;
13	import java.util.concurrent.atomic.AtomicBoolean;
14	import java.util.concurrent.locks.*;
15
16	public class LockSupportTest extends JSR166TestCase {
17	public static void main(String[] args) {
18	junit.textui.TestRunner.run(suite());
19	}
20
21	public static Test suite() {
22	return new TestSuite(LockSupportTest.class);
23	}
24
25	/**
26	* park is released by subsequent unpark
27	*/
28	public void testParkBeforeUnpark() throws InterruptedException {
29	final CountDownLatch threadStarted = new CountDownLatch(1);
30	Thread t = new Thread(new CheckedRunnable() {
31	public void realRun() {
32	threadStarted.countDown();
33	LockSupport.park();
34	}});
35
36	t.start();
37	threadStarted.await();
38	Thread.sleep(SHORT_DELAY_MS);
39	LockSupport.unpark(t);
40	joinWith(t);
41	}
42
43	/**
44	* parkUntil is released by subsequent unpark
45	*/
46	public void testParkUntilBeforeUnpark() throws InterruptedException {
47	final CountDownLatch threadStarted = new CountDownLatch(1);
48	Thread t = new Thread(new CheckedRunnable() {
49	public void realRun() {
50	long d = new Date().getTime() + LONG_DELAY_MS;
51	long nanos = LONG_DELAY_MS * 1000L * 1000L;
52	long t0 = System.nanoTime();
53	threadStarted.countDown();
54	LockSupport.parkUntil(d);
55	assertTrue(System.nanoTime() - t0 < nanos);
56	}});
57
58	t.start();
59	threadStarted.await();
60	Thread.sleep(SHORT_DELAY_MS);
61	LockSupport.unpark(t);
62	joinWith(t);
63	}
64
65	/**
66	* parkNanos is released by subsequent unpark
67	*/
68	public void testParkNanosBeforeUnpark() throws InterruptedException {
69	final CountDownLatch threadStarted = new CountDownLatch(1);
70	Thread t = new Thread(new CheckedRunnable() {
71	public void realRun() {
72	long nanos = LONG_DELAY_MS * 1000L * 1000L;
73	long t0 = System.nanoTime();
74	threadStarted.countDown();
75	LockSupport.parkNanos(nanos);
76	assertTrue(System.nanoTime() - t0 < nanos);
77	}});
78
79	t.start();
80	threadStarted.await();
81	Thread.sleep(SHORT_DELAY_MS);
82	LockSupport.unpark(t);
83	joinWith(t);
84	}
85
86	/**
87	* park is released by preceding unpark
88	*/
89	public void testParkAfterUnpark() throws Exception {
90	final CountDownLatch threadStarted = new CountDownLatch(1);
91	final AtomicBoolean unparked = new AtomicBoolean(false);
92	Thread t = new Thread(new CheckedRunnable() {
93	public void realRun() throws Exception {
94	threadStarted.countDown();
95	while (!unparked.get())
96	Thread.yield();
97	LockSupport.park();
98	}});
99
100	t.start();
101	threadStarted.await();
102	LockSupport.unpark(t);
103	unparked.set(true);
104	joinWith(t);
105	}
106
107	/**
108	* parkUntil is released by preceding unpark
109	*/
110	public void testParkUntilAfterUnpark() throws Exception {
111	final CountDownLatch threadStarted = new CountDownLatch(1);
112	final AtomicBoolean unparked = new AtomicBoolean(false);
113	Thread t = new Thread(new CheckedRunnable() {
114	public void realRun() throws Exception {
115	threadStarted.countDown();
116	while (!unparked.get())
117	Thread.yield();
118	long d = new Date().getTime() + LONG_DELAY_MS;
119	long nanos = LONG_DELAY_MS * 1000L * 1000L;
120	long t0 = System.nanoTime();
121	LockSupport.parkUntil(d);
122	assertTrue(System.nanoTime() - t0 < nanos);
123	}});
124
125	t.start();
126	threadStarted.await();
127	LockSupport.unpark(t);
128	unparked.set(true);
129	joinWith(t);
130	}
131
132	/**
133	* parkNanos is released by preceding unpark
134	*/
135	public void testParkNanosAfterUnpark() throws Exception {
136	final CountDownLatch threadStarted = new CountDownLatch(1);
137	final AtomicBoolean unparked = new AtomicBoolean(false);
138	Thread t = new Thread(new CheckedRunnable() {
139	public void realRun() throws Exception {
140	threadStarted.countDown();
141	while (!unparked.get())
142	Thread.yield();
143	long nanos = LONG_DELAY_MS * 1000L * 1000L;
144	long t0 = System.nanoTime();
145	LockSupport.parkNanos(nanos);
146	assertTrue(System.nanoTime() - t0 < nanos);
147	}});
148
149	t.start();
150	threadStarted.await();
151	LockSupport.unpark(t);
152	unparked.set(true);
153	joinWith(t);
154	}
155
156	/**
157	* park is released by subsequent interrupt
158	*/
159	public void testParkBeforeInterrupt() throws InterruptedException {
160	final CountDownLatch threadStarted = new CountDownLatch(1);
161	Thread t = new Thread(new CheckedRunnable() {
162	public void realRun() {
163	assertFalse(Thread.currentThread().isInterrupted());
164	threadStarted.countDown();
165	LockSupport.park();
166	assertTrue(Thread.currentThread().isInterrupted());
167	}});
168
169	t.start();
170	threadStarted.await();
171	Thread.sleep(SHORT_DELAY_MS);
172	t.interrupt();
173	joinWith(t);
174	}
175
176	/**
177	* parkUntil is released by subsequent interrupt
178	*/
179	public void testParkUntilBeforeInterrupt() throws InterruptedException {
180	final CountDownLatch threadStarted = new CountDownLatch(1);
181	Thread t = new Thread(new CheckedRunnable() {
182	public void realRun() {
183	long d = new Date().getTime() + LONG_DELAY_MS;
184	long nanos = LONG_DELAY_MS * 1000L * 1000L;
185	long t0 = System.nanoTime();
186	threadStarted.countDown();
187	LockSupport.parkUntil(d);
188	assertTrue(System.nanoTime() - t0 < nanos);
189	}});
190
191	t.start();
192	threadStarted.await();
193	Thread.sleep(SHORT_DELAY_MS);
194	t.interrupt();
195	joinWith(t);
196	}
197
198	/**
199	* parkNanos is released by subsequent interrupt
200	*/
201	public void testParkNanosBeforeInterrupt() throws InterruptedException {
202	final CountDownLatch threadStarted = new CountDownLatch(1);
203	Thread t = new Thread(new CheckedRunnable() {
204	public void realRun() {
205	long nanos = LONG_DELAY_MS * 1000L * 1000L;
206	long t0 = System.nanoTime();
207	threadStarted.countDown();
208	LockSupport.parkNanos(nanos);
209	assertTrue(System.nanoTime() - t0 < nanos);
210	}});
211
212	t.start();
213	threadStarted.await();
214	Thread.sleep(SHORT_DELAY_MS);
215	t.interrupt();
216	joinWith(t);
217	}
218
219	/**
220	* park is released by preceding interrupt
221	*/
222	public void testParkAfterInterrupt() throws Exception {
223	final CountDownLatch threadStarted = new CountDownLatch(1);
224	final AtomicBoolean unparked = new AtomicBoolean(false);
225	Thread t = new Thread(new CheckedRunnable() {
226	public void realRun() throws Exception {
227	threadStarted.countDown();
228	while (!unparked.get())
229	Thread.yield();
230	assertTrue(Thread.currentThread().isInterrupted());
231	LockSupport.park();
232	assertTrue(Thread.currentThread().isInterrupted());
233	}});
234
235	t.start();
236	threadStarted.await();
237	t.interrupt();
238	unparked.set(true);
239	joinWith(t);
240	}
241
242	/**
243	* parkUntil is released by preceding interrupt
244	*/
245	public void testParkUntilAfterInterrupt() throws Exception {
246	final CountDownLatch threadStarted = new CountDownLatch(1);
247	final AtomicBoolean unparked = new AtomicBoolean(false);
248	Thread t = new Thread(new CheckedRunnable() {
249	public void realRun() throws Exception {
250	threadStarted.countDown();
251	while (!unparked.get())
252	Thread.yield();
253	long d = new Date().getTime() + LONG_DELAY_MS;
254	long nanos = LONG_DELAY_MS * 1000L * 1000L;
255	long t0 = System.nanoTime();
256	LockSupport.parkUntil(d);
257	assertTrue(System.nanoTime() - t0 < nanos);
258	}});
259
260	t.start();
261	threadStarted.await();
262	t.interrupt();
263	unparked.set(true);
264	joinWith(t);
265	}
266
267	/**
268	* parkNanos is released by preceding interrupt
269	*/
270	public void testParkNanosAfterInterrupt() throws Exception {
271	final CountDownLatch threadStarted = new CountDownLatch(1);
272	final AtomicBoolean unparked = new AtomicBoolean(false);
273	Thread t = new Thread(new CheckedRunnable() {
274	public void realRun() throws Exception {
275	threadStarted.countDown();
276	while (!unparked.get())
277	Thread.yield();
278	long nanos = LONG_DELAY_MS * 1000L * 1000L;
279	long t0 = System.nanoTime();
280	LockSupport.parkNanos(nanos);
281	assertTrue(System.nanoTime() - t0 < nanos);
282	}});
283
284	t.start();
285	threadStarted.await();
286	t.interrupt();
287	unparked.set(true);
288	joinWith(t);
289	}
290
291	/**
292	* parkNanos times out if not unparked
293	*/
294	public void testParkNanosTimesOut() throws InterruptedException {
295	Thread t = new Thread(new CheckedRunnable() {
296	public void realRun() {
297	final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
298	long t0 = System.nanoTime();
299	LockSupport.parkNanos(timeoutNanos);
300	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
301	}});
302
303	t.start();
304	joinWith(t);
305	}
306
307
308	/**
309	* parkUntil times out if not unparked
310	*/
311	public void testParkUntilTimesOut() throws InterruptedException {
312	Thread t = new Thread(new CheckedRunnable() {
313	public void realRun() {
314	long d = new Date().getTime() + SHORT_DELAY_MS;
315	// beware of rounding
316	long timeoutNanos = (SHORT_DELAY_MS - 1) * 1000L * 1000L;
317	long t0 = System.nanoTime();
318	LockSupport.parkUntil(d);
319	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
320	}});
321
322	t.start();
323	joinWith(t);
324	}
325
326	/**
327	* parkUntil(0) returns immediately
328	* Requires hotspot fix for:
329	* 6763959 java.util.concurrent.locks.LockSupport.parkUntil(0) blocks forever
330	*/
331	public void XXXtestParkUntil0Returns() throws InterruptedException {
332	Thread t = new Thread(new CheckedRunnable() {
333	public void realRun() {
334	LockSupport.parkUntil(0L);
335	}});
336
337	t.start();
338	joinWith(t);
339	}
340
341	private void joinWith(Thread t) throws InterruptedException {
342	t.join(MEDIUM_DELAY_MS);
343	if (t.isAlive()) {
344	fail("Test timed out");
345	t.interrupt();
346	}
347	}
348	}