1
public class ThreadLocalTest {
2
    private List<String> messages = Lists.newArrayList();
3

4
    public static final ThreadLocal<ThreadLocalTest> holder = ThreadLocal.withInitial(ThreadLocalTest::new);
5

6
    public static void add(String message) {
7
        holder.get().messages.add(message);
8
    }
9

10
    public static List<String> clear() {
11
        List<String> messages = holder.get().messages;
12
        holder.remove();
13

14
        System.out.println("size: " + holder.get().messages.size());
15
        return messages;
16
    }
17

18
    public static void main(String[] args) {
19
        ThreadLocalTest.add("testsetestse");
20
        System.out.println(holder.get().messages);
21
        ThreadLocalTest.clear();
22
    }
23
}

1
[testsetestse]
2
size: 0

1
public class ThreadLocalDemo {
2

3
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InterruptedException {
4
        Thread t = new Thread(()->test("abc",false));
5
        t.start();
6
        t.join();
7
        System.out.println("--gc后--");
8
        Thread t2 = new Thread(() -> test("def", true));
9
        t2.start();
10
        t2.join();
11
    }
12

13
    private static void test(String s,boolean isGC)  {
14
        try {
15
            new ThreadLocal<>().set(s);
16
            if (isGC) {
17
                System.gc();
18
            }
19
            Thread t = Thread.currentThread();
20
            Class<? extends Thread> clz = t.getClass();
21
            Field field = clz.getDeclaredField("threadLocals");
22
            field.setAccessible(true);
23
            Object ThreadLocalMap = field.get(t);
24
            Class<?> tlmClass = ThreadLocalMap.getClass();
25
            Field tableField = tlmClass.getDeclaredField("table");
26
            tableField.setAccessible(true);
27
            Object[] arr = (Object[]) tableField.get(ThreadLocalMap);
28
            for (Object o : arr) {
29
                if (o != null) {
30
                    Class<?> entryClass = o.getClass();
31
                    Field valueField = entryClass.getDeclaredField("value");
32
                    Field referenceField = entryClass.getSuperclass().getSuperclass().getDeclaredField("referent");
33
                    valueField.setAccessible(true);
34
                    referenceField.setAccessible(true);
35
                    System.out.println(String.format("弱引用key:%s,值:%s", referenceField.get(o), valueField.get(o)));
36
                }
37
            }
38
        } catch (Exception e) {
39
            e.printStackTrace();
40
        }
41
    }
42
}

1
弱引用key:java.lang.ThreadLocal@433619b6,値:abc
2
弱引用key:java.lang.ThreadLocal@418a15e3,値:java.lang.ref.SoftReference@bf97a12
3
--gc后--
4
弱引用key:null,值:def

1
public void set(T value) {
2
    Thread t = Thread.currentThread();
3
    ThreadLocalMap map = getMap(t);
4
    if (map != null)
5
        map.set(this, value);
6
    else
7
        createMap(t, value);
8
}
9

10
void createMap(Thread t, T firstValue) {
11
    t.threadLocals = new ThreadLocalMap(this, firstValue);
12
}

1
int i = key.threadLocalHashCode & (len-1);

1
public class ThreadLocal<T> {
2
    private final int threadLocalHashCode = nextHashCode();
3

4
    private static AtomicInteger nextHashCode = new AtomicInteger();
5

6
    private static final int HASH_INCREMENT = 0x61c88647;
7

8
    private static int nextHashCode() {
9
        return nextHashCode.getAndAdd(HASH_INCREMENT);
10
    }
11

12
    static class ThreadLocalMap {
13
        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
14
            table = new Entry[INITIAL_CAPACITY];
15
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
16

17
            table[i] = new Entry(firstKey, firstValue);
18
            size = 1;
19
            setThreshold(INITIAL_CAPACITY);
20
        }
21
    }
22
}

1
public class InheritableThreadLocalDemo {
2
    public static void main(String[] args) {
3
        ThreadLocal<String> ThreadLocal = new ThreadLocal<>();
4
        ThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<>();
5
        ThreadLocal.set("父クラスのデータ:threadLocal");
6
        inheritableThreadLocal.set("父クラスのデータ:inheritableThreadLocal");
7

8
        new Thread(new Runnable() {
9
            @Override
10
            public void run() {
11
                System.out.println("子スレッドでの父スレッドの ThreadLocal データ：" + ThreadLocal.get());
12
                System.out.println("子スレッドでの父スレッドの inheritableThreadLocal データ：" + inheritableThreadLocal.get());
13
            }
14
        }).start();
15
    }
16
}

1
子スレッドでの父スレッドの ThreadLocal データ：null
2
子スレッドでの父スレッドの inheritableThreadLocal データ：父クラスのデータ:inheritableThreadLocal

1
private void init(ThreadGroup g, Runnable target, String name,
2
                      long stackSize, AccessControlContext acc,
3
                      boolean inheritThreadLocals) {
4
    if (name == null) {
5
        throw new NullPointerException("name cannot be null");
6
    }
7

8
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
9
        this.inheritableThreadLocals =
10
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
11
    this.stackSize = stackSize;
12
    tid = nextThreadID();
13
}