ThreadLocalSupplierTest.java revision 6236:c4bd81de2868 
1/*
2 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26import java.util.concurrent.atomic.AtomicInteger;
27import java.util.function.Supplier;
28import org.testng.annotations.Test;
29import static org.testng.Assert.*;
30
31/**
32 * @test
33 * @run testng ThreadLocalSupplierTest
34 * @summary tests ThreadLocal.withInitial(<Supplier>).
35 * Adapted from java.lang.Basic functional test of ThreadLocal
36 *
37 * @author Jim Gish <jim.gish@oracle.com>
38 */
39@Test
40public class ThreadLocalSupplierTest {
41
42    static final class IntegerSupplier implements Supplier<Integer> {
43
44        private final AtomicInteger supply = new AtomicInteger(0);
45
46        @Override
47        public Integer get() {
48            return supply.getAndIncrement();
49        }
50
51        public int numCalls() {
52            return supply.intValue();
53        }
54    }
55
56    static IntegerSupplier theSupply = new IntegerSupplier();
57
58    static final class MyThreadLocal extends ThreadLocal<Integer> {
59
60        private final ThreadLocal<Integer> delegate;
61
62        public volatile boolean everCalled;
63
64        public MyThreadLocal(Supplier<Integer> supplier) {
65            delegate = ThreadLocal.<Integer>withInitial(supplier);
66        }
67
68        @Override
69        public Integer get() {
70            return delegate.get();
71        }
72
73        @Override
74        protected synchronized Integer initialValue() {
75            // this should never be called since we are using the factory instead
76            everCalled = true;
77            return null;
78        }
79    }
80
81    /**
82     * Our one and only ThreadLocal from which we get thread ids using a
83     * supplier which simply increments a counter on each call of get().
84     */
85    static MyThreadLocal threadLocal = new MyThreadLocal(theSupply);
86
87    public void testMultiThread() throws Exception {
88        final int threadCount = 500;
89        final Thread th[] = new Thread[threadCount];
90        final boolean visited[] = new boolean[threadCount];
91
92        // Create and start the threads
93        for (int i = 0; i < threadCount; i++) {
94            th[i] = new Thread() {
95                @Override
96                public void run() {
97                    final int threadId = threadLocal.get();
98                    assertFalse(visited[threadId], "visited[" + threadId + "]=" + visited[threadId]);
99                    visited[threadId] = true;
100                    // check the get() again
101                    final int secondCheckThreadId = threadLocal.get();
102                    assertEquals(secondCheckThreadId, threadId);
103                }
104            };
105            th[i].start();
106        }
107
108        // Wait for the threads to finish
109        for (int i = 0; i < threadCount; i++) {
110            th[i].join();
111        }
112
113        assertEquals(theSupply.numCalls(), threadCount);
114        // make sure the provided initialValue() has not been called
115        assertFalse(threadLocal.everCalled);
116        // Check results
117        for (int i = 0; i < threadCount; i++) {
118            assertTrue(visited[i], "visited[" + i + "]=" + visited[i]);
119        }
120    }
121
122    public void testSimple() {
123        final String expected = "OneWithEverything";
124        final ThreadLocal<String> threadLocal = ThreadLocal.<String>withInitial(() -> expected);
125        assertEquals(expected, threadLocal.get());
126    }
127}
128