【并发】ThreadLocal的实现方式

ThreadLocal 的实现涉及到 Java 内部的许多细节，紧张依赖于每个线程维护的一个 ThreadLocalMap 对象。以下是 ThreadLocal 实现的关键部分：
1. ThreadLocal 类

ThreadLocal 类本身提供了一些公共方法，如 get()、set() 和 remove()，这些方法现实上是对 ThreadLocalMap 举行操作。

1. public class ThreadLocal<T> {
2.     // 初始化 ThreadLocal 值
3.     protected T initialValue() {
4.         return null;
5.     }
7.     // 获取当前线程的 ThreadLocal 值
8.     public T get() {
9.         Thread t = Thread.currentThread();
10.         ThreadLocalMap map = getMap(t);
11.         if (map != null) {
12.             ThreadLocalMap.Entry e = map.getEntry(this);
13.             if (e != null) {
14.                 @SuppressWarnings("unchecked")
15.                 T result = (T) e.value;
16.                 return result;
17.             }
18.         }
19.         return setInitialValue();
20.     }
22.     // 设置当前线程的 ThreadLocal 值
23.     public void set(T value) {
24.         Thread t = Thread.currentThread();
25.         ThreadLocalMap map = getMap(t);
26.         if (map != null)
27.             map.set(this, value);
28.         else
29.             createMap(t, value);
30.     }
32.     // 移除当前线程的 ThreadLocal 值
33.     public void remove() {
34.         ThreadLocalMap m = getMap(Thread.currentThread());
35.         if (m != null)
36.             m.remove(this);
37.     }
39.     // 初始化值并放入 ThreadLocalMap
40.     private T setInitialValue() {
41.         T value = initialValue();
42.         Thread t = Thread.currentThread();
43.         ThreadLocalMap map = getMap(t);
44.         if (map != null)
45.             map.set(this, value);
46.         else
47.             createMap(t, value);
48.         return value;
49.     }
51.     // 获取当前线程的 ThreadLocalMap
52.     ThreadLocalMap getMap(Thread t) {
53.         return t.threadLocals;
54.     }
56.     // 创建 ThreadLocalMap
57.     void createMap(Thread t, T firstValue) {
58.         t.threadLocals = new ThreadLocalMap(this, firstValue);
59.     }
61.     // 内部类 ThreadLocalMap
62.     static class ThreadLocalMap {
63.         // ...
64.         // 定义 Entry
65.         static class Entry extends WeakReference<ThreadLocal<?>> {
66.             Object value;
67.             Entry(ThreadLocal<?> k, Object v) {
68.                 super(k);
69.                 value = v;
70.             }
71.         }
72.         
73.         // 存储 Entry 的数组
74.         private Entry[] table;
75.         
76.         // 初始化
77.         ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
78.             table = new Entry[INITIAL_CAPACITY];
79.             int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
80.             table[i] = new Entry(firstKey, firstValue);
81.             size = 1;
82.             setThreshold(INITIAL_CAPACITY);
83.         }
84.         
85.         // 获取 Entry
86.         private Entry getEntry(ThreadLocal<?> key) {
87.             int i = key.threadLocalHashCode & (table.length - 1);
88.             Entry e = table[i];
89.             if (e != null && e.get() == key)
90.                 return e;
91.             else
92.                 return getEntryAfterMiss(key, i, e);
93.         }
94.         
95.         // 设置值
96.         private void set(ThreadLocal<?> key, Object value) {
97.             Entry[] tab = table;
98.             int len = tab.length;
99.             int i = key.threadLocalHashCode & (len-1);
100.             
101.             for (Entry e = tab[i];
102.                  e != null;
103.                  e = tab[i = nextIndex(i, len)]) {
104.                 ThreadLocal<?> k = e.get();
105.                
106.                 if (k == key) {
107.                     e.value = value;
108.                     return;
109.                 }
111.                 if (k == null) {
112.                     replaceStaleEntry(key, value, i);
113.                     return;
114.                 }
115.             }
116.             
117.             tab[i] = new Entry(key, value);
118.             int sz = ++size;
119.             if (!cleanSomeSlots(i, sz) && sz >= threshold)
120.                 rehash();
121.         }
122.         
123.         // 移除 Entry
124.         private void remove(ThreadLocal<?> key) {
125.             Entry[] tab = table;
126.             int len = tab.length;
127.             int i = key.threadLocalHashCode & (len-1);
128.             for (Entry e = tab[i];
129.                  e != null;
130.                  e = tab[i = nextIndex(i, len)]) {
131.                 if (e.get() == key) {
132.                     e.clear();
133.                     expungeStaleEntry(i);
134.                     return;
135.                 }
136.             }
137.         }
138.         
139.         // 其他方法...
140.     }
141. }

复制代码

2. Thread 类中的 ThreadLocalMap

每个线程都有一个 ThreadLocalMap，这个 ThreadLocalMap 是 Thread 类中的一个成员变量，用于存储该线程的 ThreadLocal 变量。

1. public class Thread implements Runnable {
2.     // 每个线程都持有一个 ThreadLocalMap
3.     ThreadLocal.ThreadLocalMap threadLocals = null;
4.    
5.     // 其他线程相关方法和属性...
6. }

复制代码

3. ThreadLocalMap 实现

ThreadLocalMap 是 ThreadLocal 类的一个静态内部类，用于存储线程局部变量。它利用 ThreadLocal 的 hashCode 作为键，将值存储在一个 Entry 数组中。Entry 继承自 WeakReference，利用弱引用来防止内存泄漏。

• 弱引用：ThreadLocalMap 中的 Entry 利用弱引用来引用 ThreadLocal 实例，制止内存泄漏。当一个 ThreadLocal 实例不再被其他强引用引用时，GC 可以回收它，而不必要显式地移除 Entry。
  

4. 哈希算法和辩论解决

ThreadLocalMap 利用哈希算法将 ThreadLocal 实例的 hashCode 映射到 Entry 数组的索引位置。假如发生哈希辩论，则利用线性探测法解决辩论。
5. 内存管理

ThreadLocalMap 利用 WeakReference 以及定期清算逾期条目来管理内存。通过这些机制，可以防止内存泄漏，即使线程长期存在，已经不再利用的 ThreadLocal 变量也可以被 GC 回收。
总结

ThreadLocal 通过每个线程维护一个独立的 ThreadLocalMap，并利用弱引用来管理线程局部变量，从而提供线程安全的变量存储。它在多线程编程中非常有用，尤其是在必要确保线程独立性的场景中。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。