ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/LockSupportTest.java
(Generate patch)

Comparing jsr166/src/test/tck/LockSupportTest.java (file contents):
Revision 1.14 by jsr166, Wed Aug 25 00:07:03 2010 UTC vs.
Revision 1.15 by jsr166, Mon Oct 4 20:15:16 2010 UTC

# Line 1 | Line 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
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.
# Line 9 | Line 10
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 unpark occurring after park
26 >     * park is released by subsequent unpark
27       */
28 <    public void testPark() throws InterruptedException {
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 <        t.join();
83 >        joinWith(t);
84      }
85  
86      /**
87 <     * park is released by unpark occurring before park
87 >     * park is released by preceding unpark
88       */
89 <    public void testPark2() throws InterruptedException {
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 InterruptedException {
94 <                Thread.sleep(SHORT_DELAY_MS);
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 <        t.join();
103 >        unparked.set(true);
104 >        joinWith(t);
105      }
106  
107      /**
108 <     * park is released by interrupt
108 >     * parkUntil is released by preceding unpark
109       */
110 <    public void testPark3() throws InterruptedException {
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 <        t.join();
173 >        joinWith(t);
174      }
175  
176      /**
177 <     * park returns if interrupted before park
177 >     * parkUntil is released by subsequent interrupt
178       */
179 <    public void testPark4() throws InterruptedException {
180 <        final ReentrantLock lock = new ReentrantLock();
72 <        lock.lock();
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 <                lock.lock();
184 <                LockSupport.park();
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 <        lock.unlock();
217 <        t.join();
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 testParkNanos() throws InterruptedException {
294 >    public void testParkNanosTimesOut() throws InterruptedException {
295          Thread t = new Thread(new CheckedRunnable() {
296              public void realRun() {
297 <                LockSupport.parkNanos(1000);
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 <        t.join();
304 >        joinWith(t);
305      }
306  
307  
308      /**
309       * parkUntil times out if not unparked
310       */
311 <    public void testParkUntil() throws InterruptedException {
311 >    public void testParkUntilTimesOut() throws InterruptedException {
312          Thread t = new Thread(new CheckedRunnable() {
313              public void realRun() {
314 <                long d = new Date().getTime() + 100;
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 <        t.join();
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   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines