test/tck/ExchangerTest.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 static java.util.concurrent.TimeUnit.MILLISECONDS;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Exchanger;
import java.util.concurrent.TimeoutException;

import junit.framework.Test;
import junit.framework.TestSuite;

public class ExchangerTest extends JSR166TestCase {

    public static void main(String[] args) {
        main(suite(), args);
    }
    public static Test suite() {
        return new TestSuite(ExchangerTest.class);
    }

    /**
     * exchange exchanges objects across two threads
     */
    public void testExchange() {
        final Exchanger<Item> e = new Exchanger<>();
        Thread t1 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertSame(one, e.exchange(two));
                assertSame(two, e.exchange(one));
            }});
        Thread t2 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertSame(two, e.exchange(one));
                assertSame(one, e.exchange(two));
            }});

        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * timed exchange exchanges objects across two threads
     */
    public void testTimedExchange() {
        final Exchanger<Item> e = new Exchanger<>();
        Thread t1 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                assertSame(one, e.exchange(two, LONG_DELAY_MS, MILLISECONDS));
                assertSame(two, e.exchange(one, LONG_DELAY_MS, MILLISECONDS));
            }});
        Thread t2 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                assertSame(two, e.exchange(one, LONG_DELAY_MS, MILLISECONDS));
                assertSame(one, e.exchange(two, LONG_DELAY_MS, MILLISECONDS));
            }});

        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * interrupt during wait for exchange throws InterruptedException
     */
    public void testExchange_InterruptedException() {
        final Exchanger<Item> e = new Exchanger<>();
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
            public void realRun() throws InterruptedException {
                threadStarted.countDown();
                e.exchange(one);
            }});

        await(threadStarted);
        t.interrupt();
        awaitTermination(t);
    }

    /**
     * interrupt during wait for timed exchange throws InterruptedException
     */
    public void testTimedExchange_InterruptedException() {
        final Exchanger<Item> e = new Exchanger<>();
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                e.exchange(null, LONG_DELAY_MS, MILLISECONDS);
            }});

        await(threadStarted);
        t.interrupt();
        awaitTermination(t);
    }

    /**
     * timeout during wait for timed exchange throws TimeoutException
     */
    public void testExchange_TimeoutException() {
        final Exchanger<Item> e = new Exchanger<>();
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                long startTime = System.nanoTime();
                try {
                    e.exchange(null, timeoutMillis(), MILLISECONDS);
                    shouldThrow();
                } catch (TimeoutException success) {}
                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
            }});

        awaitTermination(t);
    }

    /**
     * If one exchanging thread is interrupted, another succeeds.
     */
    public void testReplacementAfterExchange() {
        final Exchanger<Item> e = new Exchanger<>();
        final CountDownLatch exchanged = new CountDownLatch(2);
        final CountDownLatch interrupted = new CountDownLatch(1);
        Thread t1 = newStartedThread(new CheckedInterruptedRunnable() {
            public void realRun() throws InterruptedException {
                assertSame(two, e.exchange(one));
                exchanged.countDown();
                e.exchange(two);
            }});
        Thread t2 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertSame(one, e.exchange(two));
                exchanged.countDown();
                await(interrupted);
                assertSame(three, e.exchange(one));
            }});
        Thread t3 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                await(interrupted);
                assertSame(one, e.exchange(three));
            }});

        await(exchanged);
        t1.interrupt();
        awaitTermination(t1);
        interrupted.countDown();
        awaitTermination(t2);
        awaitTermination(t3);
    }

}
Revision:	1.27
Committed:	Wed Jan 27 01:57:24 2021 UTC (3 years, 2 months ago) by jsr166
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.26:	+6 -6 lines
Log Message:	use diamond <> pervasively
#	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 static java.util.concurrent.TimeUnit.MILLISECONDS;
10
11	import java.util.concurrent.CountDownLatch;
12	import java.util.concurrent.Exchanger;
13	import java.util.concurrent.TimeoutException;
14
15	import junit.framework.Test;
16	import junit.framework.TestSuite;
17
18	public class ExchangerTest extends JSR166TestCase {
19
20	public static void main(String[] args) {
21	main(suite(), args);
22	}
23	public static Test suite() {
24	return new TestSuite(ExchangerTest.class);
25	}
26
27	/**
28	* exchange exchanges objects across two threads
29	*/
30	public void testExchange() {
31	final Exchanger<Item> e = new Exchanger<>();
32	Thread t1 = newStartedThread(new CheckedRunnable() {
33	public void realRun() throws InterruptedException {
34	assertSame(one, e.exchange(two));
35	assertSame(two, e.exchange(one));
36	}});
37	Thread t2 = newStartedThread(new CheckedRunnable() {
38	public void realRun() throws InterruptedException {
39	assertSame(two, e.exchange(one));
40	assertSame(one, e.exchange(two));
41	}});
42
43	awaitTermination(t1);
44	awaitTermination(t2);
45	}
46
47	/**
48	* timed exchange exchanges objects across two threads
49	*/
50	public void testTimedExchange() {
51	final Exchanger<Item> e = new Exchanger<>();
52	Thread t1 = newStartedThread(new CheckedRunnable() {
53	public void realRun() throws Exception {
54	assertSame(one, e.exchange(two, LONG_DELAY_MS, MILLISECONDS));
55	assertSame(two, e.exchange(one, LONG_DELAY_MS, MILLISECONDS));
56	}});
57	Thread t2 = newStartedThread(new CheckedRunnable() {
58	public void realRun() throws Exception {
59	assertSame(two, e.exchange(one, LONG_DELAY_MS, MILLISECONDS));
60	assertSame(one, e.exchange(two, LONG_DELAY_MS, MILLISECONDS));
61	}});
62
63	awaitTermination(t1);
64	awaitTermination(t2);
65	}
66
67	/**
68	* interrupt during wait for exchange throws InterruptedException
69	*/
70	public void testExchange_InterruptedException() {
71	final Exchanger<Item> e = new Exchanger<>();
72	final CountDownLatch threadStarted = new CountDownLatch(1);
73	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
74	public void realRun() throws InterruptedException {
75	threadStarted.countDown();
76	e.exchange(one);
77	}});
78
79	await(threadStarted);
80	t.interrupt();
81	awaitTermination(t);
82	}
83
84	/**
85	* interrupt during wait for timed exchange throws InterruptedException
86	*/
87	public void testTimedExchange_InterruptedException() {
88	final Exchanger<Item> e = new Exchanger<>();
89	final CountDownLatch threadStarted = new CountDownLatch(1);
90	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
91	public void realRun() throws Exception {
92	threadStarted.countDown();
93	e.exchange(null, LONG_DELAY_MS, MILLISECONDS);
94	}});
95
96	await(threadStarted);
97	t.interrupt();
98	awaitTermination(t);
99	}
100
101	/**
102	* timeout during wait for timed exchange throws TimeoutException
103	*/
104	public void testExchange_TimeoutException() {
105	final Exchanger<Item> e = new Exchanger<>();
106	Thread t = newStartedThread(new CheckedRunnable() {
107	public void realRun() throws Exception {
108	long startTime = System.nanoTime();
109	try {
110	e.exchange(null, timeoutMillis(), MILLISECONDS);
111	shouldThrow();
112	} catch (TimeoutException success) {}
113	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
114	}});
115
116	awaitTermination(t);
117	}
118
119	/**
120	* If one exchanging thread is interrupted, another succeeds.
121	*/
122	public void testReplacementAfterExchange() {
123	final Exchanger<Item> e = new Exchanger<>();
124	final CountDownLatch exchanged = new CountDownLatch(2);
125	final CountDownLatch interrupted = new CountDownLatch(1);
126	Thread t1 = newStartedThread(new CheckedInterruptedRunnable() {
127	public void realRun() throws InterruptedException {
128	assertSame(two, e.exchange(one));
129	exchanged.countDown();
130	e.exchange(two);
131	}});
132	Thread t2 = newStartedThread(new CheckedRunnable() {
133	public void realRun() throws InterruptedException {
134	assertSame(one, e.exchange(two));
135	exchanged.countDown();
136	await(interrupted);
137	assertSame(three, e.exchange(one));
138	}});
139	Thread t3 = newStartedThread(new CheckedRunnable() {
140	public void realRun() throws InterruptedException {
141	await(interrupted);
142	assertSame(one, e.exchange(three));
143	}});
144
145	await(exchanged);
146	t1.interrupt();
147	awaitTermination(t1);
148	interrupted.countDown();
149	awaitTermination(t2);
150	awaitTermination(t3);
151	}
152
153	}