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