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/publicdomain/zero/1.0/
 * 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 = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                threadStarted.countDown();
                LockSupport.park();
            }});

        threadStarted.await();
        delay(SHORT_DELAY_MS);
        LockSupport.unpark(t);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * parkUntil is released by subsequent unpark
     */
    public void testParkUntilBeforeUnpark() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = newStartedThread(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);
            }});

        threadStarted.await();
        delay(SHORT_DELAY_MS);
        LockSupport.unpark(t);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * parkNanos is released by subsequent unpark
     */
    public void testParkNanosBeforeUnpark() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = newStartedThread(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);
            }});

        threadStarted.await();
        delay(SHORT_DELAY_MS);
        LockSupport.unpark(t);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * 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 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                while (!unparked.get())
                    Thread.yield();
                LockSupport.park();
            }});

        threadStarted.await();
        LockSupport.unpark(t);
        unparked.set(true);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * 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 = newStartedThread(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);
            }});

        threadStarted.await();
        LockSupport.unpark(t);
        unparked.set(true);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * 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 = newStartedThread(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);
            }});

        threadStarted.await();
        LockSupport.unpark(t);
        unparked.set(true);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

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

        threadStarted.await();
        delay(SHORT_DELAY_MS);
        t.interrupt();
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

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

        threadStarted.await();
        delay(SHORT_DELAY_MS);
        t.interrupt();
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

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

        threadStarted.await();
        delay(SHORT_DELAY_MS);
        t.interrupt();
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * 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 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                while (!unparked.get())
                    Thread.yield();
                assertTrue(Thread.currentThread().isInterrupted());
                LockSupport.park();
                assertTrue(Thread.currentThread().isInterrupted());
            }});

        threadStarted.await();
        t.interrupt();
        unparked.set(true);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * 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 = newStartedThread(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();
                assertTrue(Thread.currentThread().isInterrupted());
                LockSupport.parkUntil(d);
                assertTrue(System.nanoTime() - t0 < nanos);
                assertTrue(Thread.currentThread().isInterrupted());
            }});

        threadStarted.await();
        t.interrupt();
        unparked.set(true);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * 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 = newStartedThread(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();
                assertTrue(Thread.currentThread().isInterrupted());
                LockSupport.parkNanos(nanos);
                assertTrue(System.nanoTime() - t0 < nanos);
                assertTrue(Thread.currentThread().isInterrupted());
            }});

        threadStarted.await();
        t.interrupt();
        unparked.set(true);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

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

        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * parkUntil times out if not unparked
     */
    public void testParkUntilTimesOut() throws InterruptedException {
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                for (;;) {
                    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);
                    // parkUntil may return spuriously
                    if (System.nanoTime() - t0 >= timeoutNanos)
                        return;
                }
            }});

        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * getBlocker(null) throws NullPointerException
     */
    public void testGetBlockerNull() {
        try {
            LockSupport.getBlocker(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * parkUntil(0) returns immediately.
     *
     * Requires hotspot fix for:
     * 6763959 java.util.concurrent.locks.LockSupport.parkUntil(0) blocks forever
     * which is in jdk7-b118 and 6u25.
     */
    public void testParkUntil0Returns() throws InterruptedException {
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                LockSupport.parkUntil(0L);
            }});

        awaitTermination(t);
    }
}
Revision:	1.22
Committed:	Fri May 27 19:44:42 2011 UTC (12 years, 11 months ago) by jsr166
Branch:	MAIN
Changes since 1.21:	+0 -1 lines
Log Message:	whitespace
#	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/publicdomain/zero/1.0/
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 = newStartedThread(new CheckedRunnable() {
31	public void realRun() {
32	threadStarted.countDown();
33	LockSupport.park();
34	}});
35
36	threadStarted.await();
37	delay(SHORT_DELAY_MS);
38	LockSupport.unpark(t);
39	awaitTermination(t, MEDIUM_DELAY_MS);
40	}
41
42	/**
43	* parkUntil is released by subsequent unpark
44	*/
45	public void testParkUntilBeforeUnpark() throws InterruptedException {
46	final CountDownLatch threadStarted = new CountDownLatch(1);
47	Thread t = newStartedThread(new CheckedRunnable() {
48	public void realRun() {
49	long d = new Date().getTime() + LONG_DELAY_MS;
50	long nanos = LONG_DELAY_MS * 1000L * 1000L;
51	long t0 = System.nanoTime();
52	threadStarted.countDown();
53	LockSupport.parkUntil(d);
54	assertTrue(System.nanoTime() - t0 < nanos);
55	}});
56
57	threadStarted.await();
58	delay(SHORT_DELAY_MS);
59	LockSupport.unpark(t);
60	awaitTermination(t, MEDIUM_DELAY_MS);
61	}
62
63	/**
64	* parkNanos is released by subsequent unpark
65	*/
66	public void testParkNanosBeforeUnpark() throws InterruptedException {
67	final CountDownLatch threadStarted = new CountDownLatch(1);
68	Thread t = newStartedThread(new CheckedRunnable() {
69	public void realRun() {
70	long nanos = LONG_DELAY_MS * 1000L * 1000L;
71	long t0 = System.nanoTime();
72	threadStarted.countDown();
73	LockSupport.parkNanos(nanos);
74	assertTrue(System.nanoTime() - t0 < nanos);
75	}});
76
77	threadStarted.await();
78	delay(SHORT_DELAY_MS);
79	LockSupport.unpark(t);
80	awaitTermination(t, MEDIUM_DELAY_MS);
81	}
82
83	/**
84	* park is released by preceding unpark
85	*/
86	public void testParkAfterUnpark() throws Exception {
87	final CountDownLatch threadStarted = new CountDownLatch(1);
88	final AtomicBoolean unparked = new AtomicBoolean(false);
89	Thread t = newStartedThread(new CheckedRunnable() {
90	public void realRun() throws Exception {
91	threadStarted.countDown();
92	while (!unparked.get())
93	Thread.yield();
94	LockSupport.park();
95	}});
96
97	threadStarted.await();
98	LockSupport.unpark(t);
99	unparked.set(true);
100	awaitTermination(t, MEDIUM_DELAY_MS);
101	}
102
103	/**
104	* parkUntil is released by preceding unpark
105	*/
106	public void testParkUntilAfterUnpark() throws Exception {
107	final CountDownLatch threadStarted = new CountDownLatch(1);
108	final AtomicBoolean unparked = new AtomicBoolean(false);
109	Thread t = newStartedThread(new CheckedRunnable() {
110	public void realRun() throws Exception {
111	threadStarted.countDown();
112	while (!unparked.get())
113	Thread.yield();
114	long d = new Date().getTime() + LONG_DELAY_MS;
115	long nanos = LONG_DELAY_MS * 1000L * 1000L;
116	long t0 = System.nanoTime();
117	LockSupport.parkUntil(d);
118	assertTrue(System.nanoTime() - t0 < nanos);
119	}});
120
121	threadStarted.await();
122	LockSupport.unpark(t);
123	unparked.set(true);
124	awaitTermination(t, MEDIUM_DELAY_MS);
125	}
126
127	/**
128	* parkNanos is released by preceding unpark
129	*/
130	public void testParkNanosAfterUnpark() throws Exception {
131	final CountDownLatch threadStarted = new CountDownLatch(1);
132	final AtomicBoolean unparked = new AtomicBoolean(false);
133	Thread t = newStartedThread(new CheckedRunnable() {
134	public void realRun() throws Exception {
135	threadStarted.countDown();
136	while (!unparked.get())
137	Thread.yield();
138	long nanos = LONG_DELAY_MS * 1000L * 1000L;
139	long t0 = System.nanoTime();
140	LockSupport.parkNanos(nanos);
141	assertTrue(System.nanoTime() - t0 < nanos);
142	}});
143
144	threadStarted.await();
145	LockSupport.unpark(t);
146	unparked.set(true);
147	awaitTermination(t, MEDIUM_DELAY_MS);
148	}
149
150	/**
151	* park is released by subsequent interrupt
152	*/
153	public void testParkBeforeInterrupt() throws InterruptedException {
154	final CountDownLatch threadStarted = new CountDownLatch(1);
155	Thread t = newStartedThread(new CheckedRunnable() {
156	public void realRun() {
157	assertFalse(Thread.currentThread().isInterrupted());
158	threadStarted.countDown();
159	do {
160	LockSupport.park();
161	// park may return spuriously
162	} while (! Thread.currentThread().isInterrupted());
163	}});
164
165	threadStarted.await();
166	delay(SHORT_DELAY_MS);
167	t.interrupt();
168	awaitTermination(t, MEDIUM_DELAY_MS);
169	}
170
171	/**
172	* parkUntil is released by subsequent interrupt
173	*/
174	public void testParkUntilBeforeInterrupt() throws InterruptedException {
175	final CountDownLatch threadStarted = new CountDownLatch(1);
176	Thread t = newStartedThread(new CheckedRunnable() {
177	public void realRun() {
178	long d = new Date().getTime() + LONG_DELAY_MS;
179	long nanos = LONG_DELAY_MS * 1000L * 1000L;
180	long t0 = System.nanoTime();
181	assertFalse(Thread.currentThread().isInterrupted());
182	threadStarted.countDown();
183	do {
184	LockSupport.parkUntil(d);
185	// parkUntil may return spuriously
186	} while (! Thread.currentThread().isInterrupted());
187	assertTrue(System.nanoTime() - t0 < nanos);
188	}});
189
190	threadStarted.await();
191	delay(SHORT_DELAY_MS);
192	t.interrupt();
193	awaitTermination(t, MEDIUM_DELAY_MS);
194	}
195
196	/**
197	* parkNanos is released by subsequent interrupt
198	*/
199	public void testParkNanosBeforeInterrupt() throws InterruptedException {
200	final CountDownLatch threadStarted = new CountDownLatch(1);
201	Thread t = newStartedThread(new CheckedRunnable() {
202	public void realRun() {
203	long nanos = LONG_DELAY_MS * 1000L * 1000L;
204	long t0 = System.nanoTime();
205	assertFalse(Thread.currentThread().isInterrupted());
206	threadStarted.countDown();
207	do {
208	LockSupport.parkNanos(nanos);
209	// parkNanos may return spuriously
210	} while (! Thread.currentThread().isInterrupted());
211	assertTrue(System.nanoTime() - t0 < nanos);
212	}});
213
214	threadStarted.await();
215	delay(SHORT_DELAY_MS);
216	t.interrupt();
217	awaitTermination(t, MEDIUM_DELAY_MS);
218	}
219
220	/**
221	* park is released by preceding interrupt
222	*/
223	public void testParkAfterInterrupt() throws Exception {
224	final CountDownLatch threadStarted = new CountDownLatch(1);
225	final AtomicBoolean unparked = new AtomicBoolean(false);
226	Thread t = newStartedThread(new CheckedRunnable() {
227	public void realRun() throws Exception {
228	threadStarted.countDown();
229	while (!unparked.get())
230	Thread.yield();
231	assertTrue(Thread.currentThread().isInterrupted());
232	LockSupport.park();
233	assertTrue(Thread.currentThread().isInterrupted());
234	}});
235
236	threadStarted.await();
237	t.interrupt();
238	unparked.set(true);
239	awaitTermination(t, MEDIUM_DELAY_MS);
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 = newStartedThread(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	assertTrue(Thread.currentThread().isInterrupted());
257	LockSupport.parkUntil(d);
258	assertTrue(System.nanoTime() - t0 < nanos);
259	assertTrue(Thread.currentThread().isInterrupted());
260	}});
261
262	threadStarted.await();
263	t.interrupt();
264	unparked.set(true);
265	awaitTermination(t, MEDIUM_DELAY_MS);
266	}
267
268	/**
269	* parkNanos is released by preceding interrupt
270	*/
271	public void testParkNanosAfterInterrupt() throws Exception {
272	final CountDownLatch threadStarted = new CountDownLatch(1);
273	final AtomicBoolean unparked = new AtomicBoolean(false);
274	Thread t = newStartedThread(new CheckedRunnable() {
275	public void realRun() throws Exception {
276	threadStarted.countDown();
277	while (!unparked.get())
278	Thread.yield();
279	long nanos = LONG_DELAY_MS * 1000L * 1000L;
280	long t0 = System.nanoTime();
281	assertTrue(Thread.currentThread().isInterrupted());
282	LockSupport.parkNanos(nanos);
283	assertTrue(System.nanoTime() - t0 < nanos);
284	assertTrue(Thread.currentThread().isInterrupted());
285	}});
286
287	threadStarted.await();
288	t.interrupt();
289	unparked.set(true);
290	awaitTermination(t, MEDIUM_DELAY_MS);
291	}
292
293	/**
294	* parkNanos times out if not unparked
295	*/
296	public void testParkNanosTimesOut() throws InterruptedException {
297	Thread t = newStartedThread(new CheckedRunnable() {
298	public void realRun() {
299	for (;;) {
300	long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
301	long t0 = System.nanoTime();
302	LockSupport.parkNanos(timeoutNanos);
303	// parkNanos may return spuriously
304	if (System.nanoTime() - t0 >= timeoutNanos)
305	return;
306	}
307	}});
308
309	awaitTermination(t, MEDIUM_DELAY_MS);
310	}
311
312	/**
313	* parkUntil times out if not unparked
314	*/
315	public void testParkUntilTimesOut() throws InterruptedException {
316	Thread t = newStartedThread(new CheckedRunnable() {
317	public void realRun() {
318	for (;;) {
319	long d = new Date().getTime() + SHORT_DELAY_MS;
320	// beware of rounding
321	long timeoutNanos = (SHORT_DELAY_MS - 1) * 1000L * 1000L;
322	long t0 = System.nanoTime();
323	LockSupport.parkUntil(d);
324	// parkUntil may return spuriously
325	if (System.nanoTime() - t0 >= timeoutNanos)
326	return;
327	}
328	}});
329
330	awaitTermination(t, MEDIUM_DELAY_MS);
331	}
332
333	/**
334	* getBlocker(null) throws NullPointerException
335	*/
336	public void testGetBlockerNull() {
337	try {
338	LockSupport.getBlocker(null);
339	shouldThrow();
340	} catch (NullPointerException success) {}
341	}
342
343	/**
344	* parkUntil(0) returns immediately.
345	*
346	* Requires hotspot fix for:
347	* 6763959 java.util.concurrent.locks.LockSupport.parkUntil(0) blocks forever
348	* which is in jdk7-b118 and 6u25.
349	*/
350	public void testParkUntil0Returns() throws InterruptedException {
351	Thread t = newStartedThread(new CheckedRunnable() {
352	public void realRun() {
353	LockSupport.parkUntil(0L);
354	}});
355
356	awaitTermination(t);
357	}
358	}