test/tck/CyclicBarrierTest.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/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.locks.*;
import java.util.concurrent.atomic.*;
import static java.util.concurrent.TimeUnit.MILLISECONDS;

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

    private volatile int countAction;
    private class MyAction implements Runnable {
        public void run() { ++countAction; }
    }

    /**
     * Creating with negative parties throws IAE
     */
    public void testConstructor1() {
        try {
            new CyclicBarrier(-1, (Runnable)null);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
    }

    /**
     * Creating with negative parties and no action throws IAE
     */
    public void testConstructor2() {
        try {
            new CyclicBarrier(-1);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
    }

    /**
     * getParties returns the number of parties given in constructor
     */
    public void testGetParties() {
        CyclicBarrier b = new CyclicBarrier(2);
        assertEquals(2, b.getParties());
        assertEquals(0, b.getNumberWaiting());
    }

    /**
     * A 1-party barrier triggers after single await
     */
    public void testSingleParty() throws Exception {
        CyclicBarrier b = new CyclicBarrier(1);
        assertEquals(1, b.getParties());
        assertEquals(0, b.getNumberWaiting());
        b.await();
        b.await();
        assertEquals(0, b.getNumberWaiting());
    }

    /**
     * The supplied barrier action is run at barrier
     */
    public void testBarrierAction() throws Exception {
        countAction = 0;
        CyclicBarrier b = new CyclicBarrier(1, new MyAction());
        assertEquals(1, b.getParties());
        assertEquals(0, b.getNumberWaiting());
        b.await();
        b.await();
        assertEquals(0, b.getNumberWaiting());
        assertEquals(countAction, 2);
    }

    /**
     * A 2-party/thread barrier triggers after both threads invoke await
     */
    public void testTwoParties() throws Exception {
        final CyclicBarrier b = new CyclicBarrier(2);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                b.await();
                b.await();
                b.await();
                b.await();
            }});

        b.await();
        b.await();
        b.await();
        b.await();
        awaitTermination(t);
    }

    /**
     * An interruption in one party causes others waiting in await to
     * throw BrokenBarrierException
     */
    public void testAwait1_Interrupted_BrokenBarrier() {
        final CyclicBarrier c = new CyclicBarrier(3);
        final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
        Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
            public void realRun() throws Exception {
                pleaseInterrupt.countDown();
                c.await();
            }};
        Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
            public void realRun() throws Exception {
                pleaseInterrupt.countDown();
                c.await();
            }};

        t1.start();
        t2.start();
        await(pleaseInterrupt);
        t1.interrupt();
        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * An interruption in one party causes others waiting in timed await to
     * throw BrokenBarrierException
     */
    public void testAwait2_Interrupted_BrokenBarrier() throws Exception {
        final CyclicBarrier c = new CyclicBarrier(3);
        final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
        Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
            public void realRun() throws Exception {
                pleaseInterrupt.countDown();
                c.await(LONG_DELAY_MS, MILLISECONDS);
            }};
        Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
            public void realRun() throws Exception {
                pleaseInterrupt.countDown();
                c.await(LONG_DELAY_MS, MILLISECONDS);
            }};

        t1.start();
        t2.start();
        await(pleaseInterrupt);
        t1.interrupt();
        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * A timeout in timed await throws TimeoutException
     */
    public void testAwait3_TimeoutException() throws InterruptedException {
        final CyclicBarrier c = new CyclicBarrier(2);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                long startTime = System.nanoTime();
                try {
                    c.await(timeoutMillis(), MILLISECONDS);
                    shouldThrow();
                } catch (TimeoutException success) {}
                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
            }});

        awaitTermination(t);
    }

    /**
     * A timeout in one party causes others waiting in timed await to
     * throw BrokenBarrierException
     */
    public void testAwait4_Timeout_BrokenBarrier() throws InterruptedException {
        final CyclicBarrier c = new CyclicBarrier(3);
        Thread t1 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                try {
                    c.await(LONG_DELAY_MS, MILLISECONDS);
                    shouldThrow();
                } catch (BrokenBarrierException success) {}
            }});
        Thread t2 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                while (c.getNumberWaiting() == 0)
                    Thread.yield();
                long startTime = System.nanoTime();
                try {
                    c.await(timeoutMillis(), MILLISECONDS);
                    shouldThrow();
                } catch (TimeoutException success) {}
                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
            }});

        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * A timeout in one party causes others waiting in await to
     * throw BrokenBarrierException
     */
    public void testAwait5_Timeout_BrokenBarrier() throws InterruptedException {
        final CyclicBarrier c = new CyclicBarrier(3);
        Thread t1 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                try {
                    c.await();
                    shouldThrow();
                } catch (BrokenBarrierException success) {}
            }});
        Thread t2 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                while (c.getNumberWaiting() == 0)
                    Thread.yield();
                long startTime = System.nanoTime();
                try {
                    c.await(timeoutMillis(), MILLISECONDS);
                    shouldThrow();
                } catch (TimeoutException success) {}
                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
            }});

        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * A reset of an active barrier causes waiting threads to throw
     * BrokenBarrierException
     */
    public void testReset_BrokenBarrier() throws InterruptedException {
        Thread.interrupted(); // ensure current thread not interrupted
        final CyclicBarrier c = new CyclicBarrier(3);
        final CountDownLatch pleaseReset = new CountDownLatch(2);
        Thread t1 = new ThreadShouldThrow(BrokenBarrierException.class) {
            public void realRun() throws Exception {
                pleaseReset.countDown();
                c.await();
            }};
        Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
            public void realRun() throws Exception {
                pleaseReset.countDown();
                c.await();
            }};

        t1.start();
        t2.start();
        await(pleaseReset);
        c.reset();
        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * A reset before threads enter barrier does not throw
     * BrokenBarrierException
     */
    public void testReset_NoBrokenBarrier() throws Exception {
        final CyclicBarrier c = new CyclicBarrier(3);
        c.reset();

        Thread t1 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                c.await();
            }});
        Thread t2 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                c.await();
            }});

        c.await();
        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * All threads block while a barrier is broken.
     */
    public void testReset_Leakage() throws InterruptedException {
        final CyclicBarrier c = new CyclicBarrier(2);
        final AtomicBoolean done = new AtomicBoolean();
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                while (!done.get()) {
                    try {
                        while (c.isBroken())
                            c.reset();

                        c.await();
                        shouldThrow();
                    }
                    catch (BrokenBarrierException ok) {}
                    catch (InterruptedException ok) {}
                }}});

        for (int i = 0; i < 4; i++) {
            delay(timeoutMillis());
            t.interrupt();
        }
        done.set(true);
        t.interrupt();
        awaitTermination(t);
    }

    /**
     * Reset of a non-broken barrier does not break barrier
     */
    public void testResetWithoutBreakage() throws Exception {
        final CyclicBarrier barrier = new CyclicBarrier(3);
        for (int i = 0; i < 3; i++) {
            final CyclicBarrier start = new CyclicBarrier(3);
            Thread t1 = newStartedThread(new CheckedRunnable() {
                public void realRun() throws Exception {
                    start.await();
                    barrier.await();
                }});

            Thread t2 = newStartedThread(new CheckedRunnable() {
                public void realRun() throws Exception {
                    start.await();
                    barrier.await();
                }});

            start.await();
            barrier.await();
            awaitTermination(t1);
            awaitTermination(t2);
            assertFalse(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
            if (i == 1) barrier.reset();
            assertFalse(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
        }
    }

    /**
     * Reset of a barrier after interruption reinitializes it.
     */
    public void testResetAfterInterrupt() throws Exception {
        final CyclicBarrier barrier = new CyclicBarrier(3);
        for (int i = 0; i < 2; i++) {
            final CyclicBarrier start = new CyclicBarrier(3);
            Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
                public void realRun() throws Exception {
                    start.await();
                    barrier.await();
                }};

            Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
                public void realRun() throws Exception {
                    start.await();
                    barrier.await();
                }};

            t1.start();
            t2.start();
            start.await();
            t1.interrupt();
            awaitTermination(t1);
            awaitTermination(t2);
            assertTrue(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
            barrier.reset();
            assertFalse(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
        }
    }

    /**
     * Reset of a barrier after timeout reinitializes it.
     */
    public void testResetAfterTimeout() throws Exception {
        final CyclicBarrier barrier = new CyclicBarrier(3);
        for (int i = 0; i < 2; i++) {
            assertEquals(0, barrier.getNumberWaiting());
            Thread t1 = newStartedThread(new CheckedRunnable() {
                public void realRun() throws Exception {
                    try {
                        barrier.await();
                        shouldThrow();
                    } catch (BrokenBarrierException success) {}
                }});
            Thread t2 = newStartedThread(new CheckedRunnable() {
                public void realRun() throws Exception {
                    while (barrier.getNumberWaiting() == 0)
                        Thread.yield();
                    long startTime = System.nanoTime();
                    try {
                        barrier.await(timeoutMillis(), MILLISECONDS);
                        shouldThrow();
                    } catch (TimeoutException success) {}
                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
                }});

            awaitTermination(t1);
            awaitTermination(t2);
            assertEquals(0, barrier.getNumberWaiting());
            assertTrue(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
            barrier.reset();
            assertFalse(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
        }
    }

    /**
     * Reset of a barrier after a failed command reinitializes it.
     */
    public void testResetAfterCommandException() throws Exception {
        final CyclicBarrier barrier =
            new CyclicBarrier(3, new Runnable() {
                    public void run() {
                        throw new NullPointerException(); }});
        for (int i = 0; i < 2; i++) {
            final CyclicBarrier start = new CyclicBarrier(3);
            Thread t1 = new ThreadShouldThrow(BrokenBarrierException.class) {
                public void realRun() throws Exception {
                    start.await();
                    barrier.await();
                }};

            Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
                public void realRun() throws Exception {
                    start.await();
                    barrier.await();
                }};

            t1.start();
            t2.start();
            start.await();
            while (barrier.getNumberWaiting() < 2) { Thread.yield(); }
            try {
                barrier.await();
                shouldThrow();
            } catch (NullPointerException success) {}
            awaitTermination(t1);
            awaitTermination(t2);
            assertTrue(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
            barrier.reset();
            assertFalse(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
        }
    }
}
Revision:	1.22
Committed:	Sun May 29 13:16:40 2011 UTC (12 years, 11 months ago) by dl
Branch:	MAIN
Changes since 1.21:	+1 -0 lines
Log Message:	Ensure thread not interrupted before start of testReset_BrokenBarrier
#	Content
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/publicdomain/zero/1.0/
5	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	* Pat Fisher, Mike Judd.
7	*/
8
9	import junit.framework.*;
10	import java.util.*;
11	import java.util.concurrent.*;
12	import java.util.concurrent.locks.*;
13	import java.util.concurrent.atomic.*;
14	import static java.util.concurrent.TimeUnit.MILLISECONDS;
15
16	public class CyclicBarrierTest 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(CyclicBarrierTest.class);
22	}
23
24	private volatile int countAction;
25	private class MyAction implements Runnable {
26	public void run() { ++countAction; }
27	}
28
29	/**
30	* Creating with negative parties throws IAE
31	*/
32	public void testConstructor1() {
33	try {
34	new CyclicBarrier(-1, (Runnable)null);
35	shouldThrow();
36	} catch (IllegalArgumentException success) {}
37	}
38
39	/**
40	* Creating with negative parties and no action throws IAE
41	*/
42	public void testConstructor2() {
43	try {
44	new CyclicBarrier(-1);
45	shouldThrow();
46	} catch (IllegalArgumentException success) {}
47	}
48
49	/**
50	* getParties returns the number of parties given in constructor
51	*/
52	public void testGetParties() {
53	CyclicBarrier b = new CyclicBarrier(2);
54	assertEquals(2, b.getParties());
55	assertEquals(0, b.getNumberWaiting());
56	}
57
58	/**
59	* A 1-party barrier triggers after single await
60	*/
61	public void testSingleParty() throws Exception {
62	CyclicBarrier b = new CyclicBarrier(1);
63	assertEquals(1, b.getParties());
64	assertEquals(0, b.getNumberWaiting());
65	b.await();
66	b.await();
67	assertEquals(0, b.getNumberWaiting());
68	}
69
70	/**
71	* The supplied barrier action is run at barrier
72	*/
73	public void testBarrierAction() throws Exception {
74	countAction = 0;
75	CyclicBarrier b = new CyclicBarrier(1, new MyAction());
76	assertEquals(1, b.getParties());
77	assertEquals(0, b.getNumberWaiting());
78	b.await();
79	b.await();
80	assertEquals(0, b.getNumberWaiting());
81	assertEquals(countAction, 2);
82	}
83
84	/**
85	* A 2-party/thread barrier triggers after both threads invoke await
86	*/
87	public void testTwoParties() throws Exception {
88	final CyclicBarrier b = new CyclicBarrier(2);
89	Thread t = newStartedThread(new CheckedRunnable() {
90	public void realRun() throws Exception {
91	b.await();
92	b.await();
93	b.await();
94	b.await();
95	}});
96
97	b.await();
98	b.await();
99	b.await();
100	b.await();
101	awaitTermination(t);
102	}
103
104	/**
105	* An interruption in one party causes others waiting in await to
106	* throw BrokenBarrierException
107	*/
108	public void testAwait1_Interrupted_BrokenBarrier() {
109	final CyclicBarrier c = new CyclicBarrier(3);
110	final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
111	Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
112	public void realRun() throws Exception {
113	pleaseInterrupt.countDown();
114	c.await();
115	}};
116	Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
117	public void realRun() throws Exception {
118	pleaseInterrupt.countDown();
119	c.await();
120	}};
121
122	t1.start();
123	t2.start();
124	await(pleaseInterrupt);
125	t1.interrupt();
126	awaitTermination(t1);
127	awaitTermination(t2);
128	}
129
130	/**
131	* An interruption in one party causes others waiting in timed await to
132	* throw BrokenBarrierException
133	*/
134	public void testAwait2_Interrupted_BrokenBarrier() throws Exception {
135	final CyclicBarrier c = new CyclicBarrier(3);
136	final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
137	Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
138	public void realRun() throws Exception {
139	pleaseInterrupt.countDown();
140	c.await(LONG_DELAY_MS, MILLISECONDS);
141	}};
142	Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
143	public void realRun() throws Exception {
144	pleaseInterrupt.countDown();
145	c.await(LONG_DELAY_MS, MILLISECONDS);
146	}};
147
148	t1.start();
149	t2.start();
150	await(pleaseInterrupt);
151	t1.interrupt();
152	awaitTermination(t1);
153	awaitTermination(t2);
154	}
155
156	/**
157	* A timeout in timed await throws TimeoutException
158	*/
159	public void testAwait3_TimeoutException() throws InterruptedException {
160	final CyclicBarrier c = new CyclicBarrier(2);
161	Thread t = newStartedThread(new CheckedRunnable() {
162	public void realRun() throws Exception {
163	long startTime = System.nanoTime();
164	try {
165	c.await(timeoutMillis(), MILLISECONDS);
166	shouldThrow();
167	} catch (TimeoutException success) {}
168	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
169	}});
170
171	awaitTermination(t);
172	}
173
174	/**
175	* A timeout in one party causes others waiting in timed await to
176	* throw BrokenBarrierException
177	*/
178	public void testAwait4_Timeout_BrokenBarrier() throws InterruptedException {
179	final CyclicBarrier c = new CyclicBarrier(3);
180	Thread t1 = newStartedThread(new CheckedRunnable() {
181	public void realRun() throws Exception {
182	try {
183	c.await(LONG_DELAY_MS, MILLISECONDS);
184	shouldThrow();
185	} catch (BrokenBarrierException success) {}
186	}});
187	Thread t2 = newStartedThread(new CheckedRunnable() {
188	public void realRun() throws Exception {
189	while (c.getNumberWaiting() == 0)
190	Thread.yield();
191	long startTime = System.nanoTime();
192	try {
193	c.await(timeoutMillis(), MILLISECONDS);
194	shouldThrow();
195	} catch (TimeoutException success) {}
196	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
197	}});
198
199	awaitTermination(t1);
200	awaitTermination(t2);
201	}
202
203	/**
204	* A timeout in one party causes others waiting in await to
205	* throw BrokenBarrierException
206	*/
207	public void testAwait5_Timeout_BrokenBarrier() throws InterruptedException {
208	final CyclicBarrier c = new CyclicBarrier(3);
209	Thread t1 = newStartedThread(new CheckedRunnable() {
210	public void realRun() throws Exception {
211	try {
212	c.await();
213	shouldThrow();
214	} catch (BrokenBarrierException success) {}
215	}});
216	Thread t2 = newStartedThread(new CheckedRunnable() {
217	public void realRun() throws Exception {
218	while (c.getNumberWaiting() == 0)
219	Thread.yield();
220	long startTime = System.nanoTime();
221	try {
222	c.await(timeoutMillis(), MILLISECONDS);
223	shouldThrow();
224	} catch (TimeoutException success) {}
225	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
226	}});
227
228	awaitTermination(t1);
229	awaitTermination(t2);
230	}
231
232	/**
233	* A reset of an active barrier causes waiting threads to throw
234	* BrokenBarrierException
235	*/
236	public void testReset_BrokenBarrier() throws InterruptedException {
237	Thread.interrupted(); // ensure current thread not interrupted
238	final CyclicBarrier c = new CyclicBarrier(3);
239	final CountDownLatch pleaseReset = new CountDownLatch(2);
240	Thread t1 = new ThreadShouldThrow(BrokenBarrierException.class) {
241	public void realRun() throws Exception {
242	pleaseReset.countDown();
243	c.await();
244	}};
245	Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
246	public void realRun() throws Exception {
247	pleaseReset.countDown();
248	c.await();
249	}};
250
251	t1.start();
252	t2.start();
253	await(pleaseReset);
254	c.reset();
255	awaitTermination(t1);
256	awaitTermination(t2);
257	}
258
259	/**
260	* A reset before threads enter barrier does not throw
261	* BrokenBarrierException
262	*/
263	public void testReset_NoBrokenBarrier() throws Exception {
264	final CyclicBarrier c = new CyclicBarrier(3);
265	c.reset();
266
267	Thread t1 = newStartedThread(new CheckedRunnable() {
268	public void realRun() throws Exception {
269	c.await();
270	}});
271	Thread t2 = newStartedThread(new CheckedRunnable() {
272	public void realRun() throws Exception {
273	c.await();
274	}});
275
276	c.await();
277	awaitTermination(t1);
278	awaitTermination(t2);
279	}
280
281	/**
282	* All threads block while a barrier is broken.
283	*/
284	public void testReset_Leakage() throws InterruptedException {
285	final CyclicBarrier c = new CyclicBarrier(2);
286	final AtomicBoolean done = new AtomicBoolean();
287	Thread t = newStartedThread(new CheckedRunnable() {
288	public void realRun() {
289	while (!done.get()) {
290	try {
291	while (c.isBroken())
292	c.reset();
293
294	c.await();
295	shouldThrow();
296	}
297	catch (BrokenBarrierException ok) {}
298	catch (InterruptedException ok) {}
299	}}});
300
301	for (int i = 0; i < 4; i++) {
302	delay(timeoutMillis());
303	t.interrupt();
304	}
305	done.set(true);
306	t.interrupt();
307	awaitTermination(t);
308	}
309
310	/**
311	* Reset of a non-broken barrier does not break barrier
312	*/
313	public void testResetWithoutBreakage() throws Exception {
314	final CyclicBarrier barrier = new CyclicBarrier(3);
315	for (int i = 0; i < 3; i++) {
316	final CyclicBarrier start = new CyclicBarrier(3);
317	Thread t1 = newStartedThread(new CheckedRunnable() {
318	public void realRun() throws Exception {
319	start.await();
320	barrier.await();
321	}});
322
323	Thread t2 = newStartedThread(new CheckedRunnable() {
324	public void realRun() throws Exception {
325	start.await();
326	barrier.await();
327	}});
328
329	start.await();
330	barrier.await();
331	awaitTermination(t1);
332	awaitTermination(t2);
333	assertFalse(barrier.isBroken());
334	assertEquals(0, barrier.getNumberWaiting());
335	if (i == 1) barrier.reset();
336	assertFalse(barrier.isBroken());
337	assertEquals(0, barrier.getNumberWaiting());
338	}
339	}
340
341	/**
342	* Reset of a barrier after interruption reinitializes it.
343	*/
344	public void testResetAfterInterrupt() throws Exception {
345	final CyclicBarrier barrier = new CyclicBarrier(3);
346	for (int i = 0; i < 2; i++) {
347	final CyclicBarrier start = new CyclicBarrier(3);
348	Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
349	public void realRun() throws Exception {
350	start.await();
351	barrier.await();
352	}};
353
354	Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
355	public void realRun() throws Exception {
356	start.await();
357	barrier.await();
358	}};
359
360	t1.start();
361	t2.start();
362	start.await();
363	t1.interrupt();
364	awaitTermination(t1);
365	awaitTermination(t2);
366	assertTrue(barrier.isBroken());
367	assertEquals(0, barrier.getNumberWaiting());
368	barrier.reset();
369	assertFalse(barrier.isBroken());
370	assertEquals(0, barrier.getNumberWaiting());
371	}
372	}
373
374	/**
375	* Reset of a barrier after timeout reinitializes it.
376	*/
377	public void testResetAfterTimeout() throws Exception {
378	final CyclicBarrier barrier = new CyclicBarrier(3);
379	for (int i = 0; i < 2; i++) {
380	assertEquals(0, barrier.getNumberWaiting());
381	Thread t1 = newStartedThread(new CheckedRunnable() {
382	public void realRun() throws Exception {
383	try {
384	barrier.await();
385	shouldThrow();
386	} catch (BrokenBarrierException success) {}
387	}});
388	Thread t2 = newStartedThread(new CheckedRunnable() {
389	public void realRun() throws Exception {
390	while (barrier.getNumberWaiting() == 0)
391	Thread.yield();
392	long startTime = System.nanoTime();
393	try {
394	barrier.await(timeoutMillis(), MILLISECONDS);
395	shouldThrow();
396	} catch (TimeoutException success) {}
397	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
398	}});
399
400	awaitTermination(t1);
401	awaitTermination(t2);
402	assertEquals(0, barrier.getNumberWaiting());
403	assertTrue(barrier.isBroken());
404	assertEquals(0, barrier.getNumberWaiting());
405	barrier.reset();
406	assertFalse(barrier.isBroken());
407	assertEquals(0, barrier.getNumberWaiting());
408	}
409	}
410
411	/**
412	* Reset of a barrier after a failed command reinitializes it.
413	*/
414	public void testResetAfterCommandException() throws Exception {
415	final CyclicBarrier barrier =
416	new CyclicBarrier(3, new Runnable() {
417	public void run() {
418	throw new NullPointerException(); }});
419	for (int i = 0; i < 2; i++) {
420	final CyclicBarrier start = new CyclicBarrier(3);
421	Thread t1 = new ThreadShouldThrow(BrokenBarrierException.class) {
422	public void realRun() throws Exception {
423	start.await();
424	barrier.await();
425	}};
426
427	Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
428	public void realRun() throws Exception {
429	start.await();
430	barrier.await();
431	}};
432
433	t1.start();
434	t2.start();
435	start.await();
436	while (barrier.getNumberWaiting() < 2) { Thread.yield(); }
437	try {
438	barrier.await();
439	shouldThrow();
440	} catch (NullPointerException success) {}
441	awaitTermination(t1);
442	awaitTermination(t2);
443	assertTrue(barrier.isBroken());
444	assertEquals(0, barrier.getNumberWaiting());
445	barrier.reset();
446	assertFalse(barrier.isBroken());
447	assertEquals(0, barrier.getNumberWaiting());
448	}
449	}
450	}