阿里架构师浅析ThreadLocal源码——黄金分割数的使用
一. 前提
最近接触到的一个项目要兼容新老系统，最终采用了ThreadLocal(实际上用的是InheritableThreadLocal)用于在子线程获取父线程中共享的变量。问题是解决了，可是后来发现对ThreadLocal的理解不够深刻，因而顺便把它的源码阅读理解了一遍。在谈到ThreadLocal以前先买个关子，先谈谈黄金分割数。本文在阅读ThreadLocal源码的时候是使用JDK8(1.8.0_181)。java
二. 黄金分割数与斐波那契数列
首先复习一下斐波那契数列，下面的推导过程来自某搜索引擎的wiki：算法
- 斐波那契数列：1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …
- 通项公式：假设F(n)为该数列的第n项（n ∈ N*），那么这句话能够写成以下形式：F(n) = F(n-1) + F(n-2)。
有趣的是，这样一个彻底是天然数的数列，通项公式倒是用无理数来表达的。并且当n趋向于无穷大时，前一项与后一项的比值愈来愈逼近0.618（或者说后一项与前一项的比值小数部分愈来愈逼近0.618），而这个值0.618就被称为黄金分割数。证实过程以下：编程
黄金分割数的准确值为(根号5 - 1)/2，约等于0.618。并发
三. 黄金分割数的应用
黄金分割数被普遍使用在美术、摄影等艺术领域，由于它具备严格的比例性、艺术性、和谐性，蕴藏着丰富的美学价值，可以激发人的美感。固然，这些不是本文研究的方向，咱们先尝试求出无符号整型和带符号整型的黄金分割数的具体值：框架
public static void main(String[] args) throws Exception {
//黄金分割数 * 2的32次方 = 2654435769 - 这个是无符号32位整数的黄金分割数对应的那个值
long c = (long) ((1L << 32) * (Math.sqrt(5) - 1) / 2);
System.out.println(c);
//强制转换为带符号为的32位整型，值为-1640531527
int i = (int) c;
System.out.println(i);
}
经过一个线段图理解一下：ide
也就是2654435769为32位无符号整数的黄金分割值，而-1640531527就是32位带符号整数的黄金分割值。而ThreadLocal中的哈希魔数正是1640531527(十六进制为0x61c88647)。为何要使用0x61c88647做为哈希魔数？这里提早说一下ThreadLocal在ThreadLocalMap(ThreadLocal在ThreadLocalMap以Key的形式存在)中的哈希求Key下标的规则：函数
哈希算法：keyIndex = ((i + 1) * HASH_INCREMENT) & (length - 1)源码分析
其中，i为ThreadLocal实例的个数，这里的HASH_INCREMENT就是哈希魔数0x61c88647，length为ThreadLocalMap中可容纳的Entry(K-V结构)的个数(或者称为容量)。在ThreadLocal中的内部类ThreadLocalMap的初始化容量为16，扩容后老是2的幂次方，所以咱们能够写个Demo模拟整个哈希的过程：性能
public class Main {
private static final int HASH_INCREMENT = 0x61c88647;
public static void main(String[] args) throws Exception {
hashCode(4);
hashCode(16);
hashCode(32);
}
private static void hashCode(int capacity) throws Exception {
int keyIndex;
for (int i = 0; i < capacity; i++) {
keyIndex = ((i + 1) * HASH_INCREMENT) & (capacity - 1);
System.out.print(keyIndex);
System.out.print(" ");
}
System.out.println();
}
}
上面的例子中，咱们分别模拟了ThreadLocalMap容量为4,16,32的状况下，不触发扩容，而且分别”放入”4,16,32个元素到容器中，输出结果以下：学习
3 2 1 0 7 14 5 12 3 10 1 8 15 6 13 4 11 2 9 0 7 14 21 28 3 10 17 24 31 6 13 20 27 2 9 16 23 30 5 12 19 26 1 8 15 22 29 4 11 18 25 0
每组的元素通过散列算法后刚好填充满了整个容器，也就是实现了完美散列。实际上，这个并非偶然，其实整个哈希算法能够转换为多项式证实：证实(x - y) * HASH_INCREMENT != 2^n * (n m)，在x != y，n != m，HASH_INCREMENT为奇数的状况下恒成立，具体证实能够自行完成。HASH_INCREMENT赋值为0x61c88647的API文档注释以下：
连续生成的哈希码之间的差别(增量值)，将隐式顺序线程本地id转换为几乎最佳分布的乘法哈希值，这些不一样的哈希值最终生成一个2的幂次方的哈希表。
四. ThreadLocal是什么
下面引用ThreadLocal的API注释：
This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its get or set method) has its own, independently initialized copy of the variable. ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or Transaction ID)
稍微翻译一下：ThreadLocal提供线程局部变量。这些变量与正常的变量不一样，由于每个线程在访问ThreadLocal实例的时候（经过其get或set方法）都有本身的、独立初始化的变量副本。ThreadLocal实例一般是类中的私有静态字段，使用它的目的是但愿将状态（例如，用户ID或事务ID）与线程关联起来。
ThreadLocal由Java界的两个大师级的做者编写，Josh Bloch和Doug Lea。Josh Bloch是JDK5语言加强、Java集合(Collection)框架的创办人以及《Effective Java》系列的做者。Doug Lea是JUC(java.util.concurrent)包的做者，Java并发编程的泰斗。因此，ThreadLocal的源码十分值得学习。
五. ThreadLocal的原理
ThreadLocal虽然叫线程本地(局部)变量，可是实际上它并不存听任何的信息，能够这样理解：它是线程(Thread)操做ThreadLocalMap中存放的变量的桥梁。它主要提供了初始化、set()、get()、remove()几个方法。这样说可能有点抽象，下面画个图说明一下在线程中使用ThreadLocal实例的set()和get()方法的简单流程图。
假设咱们有以下的代码，主线程的线程名字是main(也有可能不是main)：
public class Main {
private static final ThreadLocal<String> LOCAL = new ThreadLocal<>();
public static void main(String[] args) throws Exception{
LOCAL.set("doge");
System.out.println(LOCAL.get());
}
}
上面只描述了单线程的状况而且由于是主线程忽略了Thread t = new Thread()这一步，若是有多个线程会稍微复杂一些，可是原理是不变的，ThreadLocal实例老是经过Thread.currentThread()获取到当前操做线程实例，而后去操做线程实例中的ThreadLocalMap类型的成员变量，所以它是一个桥梁，自己不具有存储功能。
六. ThreadLocal源码分析
对于ThreadLocal的源码，咱们须要重点关注set()、get()、remove()几个方法。
1. ThreadLocal的内部属性
//获取下一个ThreadLocal实例的哈希魔数
private final int threadLocalHashCode = nextHashCode();
//原子计数器，主要到它被定义为静态
private static AtomicInteger nextHashCode = new AtomicInteger();
//哈希魔数(增加数)，也是带符号的32位整型值黄金分割值的取正
private static final int HASH_INCREMENT = 0x61c88647;
//生成下一个哈希魔数
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
这里须要注意一点，threadLocalHashCode是一个final的属性，而原子计数器变量nextHashCode和生成下一个哈希魔数的方法nextHashCode()是静态变量和静态方法，静态变量只会初始化一次。换而言之，每新建一个ThreadLocal实例，它内部的threadLocalHashCode就会增长0x61c88647。举个例子：
//t1中的threadLocalHashCode变量为0x61c88647 ThreadLocal t1 = new ThreadLocal(); //t2中的threadLocalHashCode变量为0x61c88647 + 0x61c88647 ThreadLocal t2 = new ThreadLocal(); //t3中的threadLocalHashCode变量为0x61c88647 + 0x61c88647 + 0x61c88647 ThreadLocal t3 = new ThreadLocal();
threadLocalHashCode是下面的ThreadLocalMap结构中使用的哈希算法的核心变量，对于每一个ThreadLocal实例，它的threadLocalHashCode是惟一的。
2. 内部类ThreadLocalMap的基本结构和源码分析
ThreadLocal内部类ThreadLocalMap使用了默认修饰符，也就是包(包私有)可访问的。ThreadLocalMap内部定义了一个静态类Entry。咱们重点看下ThreadLocalMap的源码，先当作员和结构部分：
/**
* ThreadLocalMap是一个定制的散列映射，仅适用于维护线程本地变量。
* 它的全部方法都是定义在ThreadLocal类以内。
* 它是包私有的，因此在Thread类中能够定义ThreadLocalMap做为变量。
* 为了处理很是大(指的是值)和长时间的用途，哈希表的Key使用了弱引用(WeakReferences)。
* 引用的队列(弱引用)再也不被使用的时候，对应的过时的条目就能经过主动删除移出哈希表。
*/
static class ThreadLocalMap {
//注意这里的Entry的Key为WeakReference<ThreadLocal<?>>
static class Entry extends WeakReference<ThreadLocal<?>> {
//这个是真正的存放的值
Object value;
// Entry的Key就是ThreadLocal实例自己，Value就是输入的值
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
//初始化容量，必须是2的幂次方
private static final int INITIAL_CAPACITY = 16;
//哈希(Entry)表，必须时扩容，长度必须为2的幂次方
private Entry[] table;
//哈希表中元素(Entry)的个数
private int size = 0;
//下一次须要扩容的阈值，默认值为0
private int threshold;
//设置下一次须要扩容的阈值，设置值为输入值len的三分之二
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
// 以len为模增长i
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
// 以len为模减小i
private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
}
这里注意到十分重要的一点：ThreadLocalMap$Entry是WeakReference(弱引用)，而且键值Key为ThreadLocal<?>实例自己，这里使用了无限定的泛型通配符。
接着看ThreadLocalMap的构造函数：
// 构造ThreadLocal时候使用，对应ThreadLocal的实例方法void createMap(Thread t, T firstValue)
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
// 哈希表默认容量为16
table = new Entry[INITIAL_CAPACITY];
// 计算第一个元素的哈希码
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
// 构造InheritableThreadLocal时候使用，基于父线程的ThreadLocalMap里面的内容进行提取放入新的ThreadLocalMap的哈希表中
// 对应ThreadLocal的静态方法static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap)
private ThreadLocalMap(ThreadLocalMap parentMap) {
Entry[] parentTable = parentMap.table;
int len = parentTable.length;
setThreshold(len);
table = new Entry[len];
// 基于父ThreadLocalMap的哈希表进行拷贝
for (Entry e : parentTable) {
if (e != null) {
@SuppressWarnings("unchecked")
ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
if (key != null) {
Object value = key.childValue(e.value);
Entry c = new Entry(key, value);
int h = key.threadLocalHashCode & (len - 1);
while (table[h] != null)
h = nextIndex(h, len);
table[h] = c;
size++;
}
}
}
}
这里注意一下，ThreadLocal的set()方法调用的时候会懒初始化一个ThreadLocalMap而且放入第一个元素。而ThreadLocalMap的私有构造是提供给静态方法ThreadLocal#createInheritedMap()使用的。
接着看ThreadLocalMap提供给ThreadLocal使用的一些实例方法：
// 若是Key在哈希表中找不到哈希槽的时候会调用此方法
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
// 这里会经过nextIndex尝试遍历整个哈希表，若是找到匹配的Key则返回Entry
// 若是哈希表中存在Key == null的状况，调用expungeStaleEntry进行清理
while (e != null) {
ThreadLocal<?> k = e.get();
if (k == key)
return e;
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
// 1.清空staleSlot对应哈希槽的Key和Value
// 2.对staleSlot到下一个空的哈希槽之间的全部可能冲突的哈希表部分槽进行重哈希，置空Key为null的槽
// 3.注意返回值是staleSlot以后的下一个空的哈希槽的哈希码
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// expunge entry at staleSlot
// 清空staleSlot对应哈希槽的Key和Value
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// Rehash until we encounter null
// 下面的过程是对staleSlot到下一个空的哈希槽之间的全部可能冲突的哈希表部分槽进行重哈希，置空Key为null的槽
Entry e;
int i;
for (i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
tab[i] = null;
// Unlike Knuth 6.4 Algorithm R, we must scan until
// null because multiple entries could have been stale.
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
// 这里个方法比较长，做用是替换哈希码为staleSlot的哈希槽中Entry的值
private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
// Back up to check for prior stale entry in current run.
// We clean out whole runs at a time to avoid continual
// incremental rehashing due to garbage collector freeing
// up refs in bunches (i.e., whenever the collector runs).
int slotToExpunge = staleSlot;
// 这个循环主要是为了找到staleSlot以前的最前面的一个Key为null的哈希槽的哈希码
for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i;
// Find either the key or trailing null slot of run, whichever
// occurs first
// 遍历staleSlot以后的哈希槽，若是Key匹配则用输入值替换
for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
// If we find key, then we need to swap it
// with the stale entry to maintain hash table order.
// The newly stale slot, or any other stale slot
// encountered above it, can then be sent to expungeStaleEntry
// to remove or rehash all of the other entries in run.
if (k == key) {
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
// Start expunge at preceding stale entry if it exists
if (slotToExpunge == staleSlot)
slotToExpunge = i;
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
// If we didn't find stale entry on backward scan, the
// first stale entry seen while scanning for key is the
// first still present in the run.
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
// Key匹配不了，则新建立一个哈希槽
// If key not found, put new entry in stale slot
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
// 这里若是当前的staleSlot和找到前置的slotToExpunge不一致会进行一次清理
// If there are any other stale entries in run, expunge them
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
// 对当前哈希表中全部的Key为null的Entry调用expungeStaleEntry
private void expungeStaleEntries() {
Entry[] tab = table;
int len = tab.length;
for (int j = 0; j < len; j++) {
Entry e = tab[j];
if (e != null && e.get() == null)
expungeStaleEntry(j);
}
}
// 清理第i个哈希槽以后的n个哈希槽，若是遍历的时候发现Entry的Key为null，则n会重置为哈希表的长度，expungeStaleEntry有可能会重哈希使得哈希表长度发生变化
private boolean cleanSomeSlots(int i, int n) {
boolean removed = false;
Entry[] tab = table;
int len = tab.length;
do {
i = nextIndex(i, len);
Entry e = tab[i];
if (e != null && e.get() == null) {
n = len;
removed = true;
i = expungeStaleEntry(i);
}
} while ( (n >>>= 1) != 0);
return removed;
}
/**
* 这个方法主要给`ThreadLocal#get()`调用，经过当前ThreadLocal实例获取哈希表中对应的Entry
*
*/
private Entry getEntry(ThreadLocal<?> key) {
// 计算Entry的哈希值
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e;
else // 注意这里，若是e为null或者Key对不上，会调用getEntryAfterMiss
return getEntryAfterMiss(key, i, e);
}
// 重哈希，必要时进行扩容
private void rehash() {
// 清理全部空的哈希槽，而且进行重哈希
expungeStaleEntries();
// Use lower threshold for doubling to avoid hysteresis
// 哈希表的哈希元素个数大于3/4阈值时候触发扩容
if (size >= threshold - threshold / 4)
resize();
}
// 扩容，简单的扩大2倍的容量
private void resize() {
Entry[] oldTab = table;
int oldLen = oldTab.length;
int newLen = oldLen * 2;
Entry[] newTab = new Entry[newLen];
int count = 0;
for (Entry e : oldTab) {
if (e != null) {
ThreadLocal<?> k = e.get();
if (k == null) {
e.value = null; // Help the GC
} else {
int h = k.threadLocalHashCode & (newLen - 1);
while (newTab[h] != null)
h = nextIndex(h, newLen);
newTab[h] = e;
count++;
}
}
}
setThreshold(newLen);
size = count;
table = newTab;
}
// 基于ThreadLocal做为key，对当前的哈希表设置值，此方法由`ThreadLocal#set()`调用
private void set(ThreadLocal<?> key, Object value) {
// We don't use a fast path as with get() because it is at
// least as common to use set() to create new entries as
// it is to replace existing ones, in which case, a fast
// path would fail more often than not.
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
// 变量哈希表
for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
// Key匹配，直接设置值
if (k == key) {
e.value = value;
return;
}
// 若是Entry的Key为null，则替换该Key为当前的key，而且设置值
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
// 清理当前新设置元素的哈希槽下标到sz段的哈希槽，若是清理成功而且sz大于阈值则触发扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
简单来讲，ThreadLocalMap是ThreadLocal真正的数据存储容器，实际上ThreadLocal数据操做的复杂部分的全部逻辑都在ThreadLocalMap中进行，而ThreadLocalMap实例是Thread的成员变量，在ThreadLocal#set()方法首次调用的时候设置到当前执行的线程实例中。若是在同一个线程中使用多个ThreadLocal实例，实际上，每一个ThreadLocal实例对应的是ThreadLocalMap的哈希表中的一个哈希槽。举个例子，在主函数主线程中使用多个ThreadLocal实例：
public class ThreadLocalMain {
private static final ThreadLocal<Integer> TL_1 = new ThreadLocal<>();
private static final ThreadLocal<String> TL_2 = new ThreadLocal<>();
private static final ThreadLocal<Long> TL_3 = new ThreadLocal<>();
public static void main(String[] args) throws Exception {
TL_1.set(1);
TL_2.set("1");
TL_3.set(1L);
Field field = Thread.class.getDeclaredField("threadLocals");
field.setAccessible(true);
Object o = field.get(Thread.currentThread());
System.out.println(o);
}
}
实际上，主线程的threadLocals属性中的哈希表中通常不止咱们上面定义的三个ThreadLocal，由于加载主线程的时候还有可能在其余地方使用到ThreadLocal，笔者某次Debug的结果以下：
用PPT画图简化一下：
上图threadLocalHashCode属性一行的表是为了标出每一个Entry的哈希槽的哈希值，实际上，threadLocalHashCode是ThreadLocal@XXXX中的一个属性，这是很显然的，原本threadLocalHashCode就是ThreadLocal的一个成员变量。
上面只是简单粗略对ThreadLocalMap的源码进行了流水帐的分析，下文会做一些详细的图，说明一下ThreadLocal和ThreadLocalMap中的一些核心操做的过程。
3. ThreadLocal的建立
从ThreadLocal的构造函数来看，ThreadLocal实例的构造并不会作任何操做，只是为了获得一个ThreadLocal的泛型实例，后续能够把它做为ThreadLocalMap$Entry的键：
// 注意threadLocalHashCode在每一个新`ThreadLocal`实例的构造同时已经肯定了
private final int threadLocalHashCode = nextHashCode();
private static AtomicInteger nextHashCode = new AtomicInteger();
private static final int HASH_INCREMENT = 0x61c88647;
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
// 经过Supplier去覆盖initialValue方法
public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
return new SuppliedThreadLocal<>(supplier);
}
// 默认公有构造函数
public ThreadLocal() {
}
注意threadLocalHashCode在每一个新ThreadLocal实例的构造同时已经肯定了，这个值也是Entry哈希表的哈希槽绑定的哈希值。
4. TreadLocal的set方法
ThreadLocal中set()方法的源码以下:
public void set(T value) {
//设置值前老是获取当前线程实例
Thread t = Thread.currentThread();
//从当前线程实例中获取threadLocals属性
ThreadLocalMap map = getMap(t);
if (map != null)
//threadLocals属性不为null则覆盖key为当前的ThreadLocal实例，值为value
map.set(this, value);
else
//threadLocals属性为null，则建立ThreadLocalMap，第一个项的Key为当前的ThreadLocal实例，值为value
createMap(t, value);
}
// 这里看到获取ThreadLocalMap实例时候老是从线程实例的成员变量获取
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
// 建立ThreadLocalMap实例的时候，会把新实例赋值到线程实例的threadLocals成员
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
上面的过程源码很简单，设置值的时候老是先获取当前线程实例而且操做它的变量threadLocals。步骤是：
- 获取当前运行线程的实例。
- 经过线程实例获取线程实例成员threadLocals(ThreadLocalMap)，若是为null，则建立一个新的ThreadLocalMap实例赋值到threadLocals。
- 经过threadLocals设置值value，若是原来的哈希槽已经存在值，则进行覆盖。
5. TreadLocal的get方法
ThreadLocal中get()方法的源码以下:
public T get() {
//获取当前线程的实例
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
//根据当前的ThreadLocal实例获取ThreadLocalMap中的Entry，使用的是ThreadLocalMap的getEntry方法
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T) e.value;
return result;
}
}
//线程实例中的threadLocals为null，则调用initialValue方法，而且建立ThreadLocalMap赋值到threadLocals
return setInitialValue();
}
private T setInitialValue() {
// 调用initialValue方法获取值
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
// ThreadLocalMap若是未初始化则进行一次建立，已初始化则直接设置值
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
protected T initialValue() {
return null;
}
initialValue()方法默认返回null，若是ThreadLocal实例没有使用过set()方法直接使用get()方法，那么ThreadLocalMap中的此ThreadLocal为Key的项会把值设置为initialValue()方法的返回值。若是想改变这个逻辑能够对initialValue()方法进行覆盖。
6. TreadLocal的remove方法
ThreadLocal中remove()方法的源码以下:
public void remove() {
//获取Thread实例中的ThreadLocalMap
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
//根据当前ThreadLocal做为Key对ThreadLocalMap的元素进行移除
m.remove(this);
}
七. ThreadLocal.ThreadLocalMap的初始化
咱们能够关注一下java.lang.Thread类里面的变量：
public class Thread implements Runnable {
//传递ThreadLocal中的ThreadLocalMap变量
ThreadLocal.ThreadLocalMap threadLocals = null;
//传递InheritableThreadLocal中的ThreadLocalMap变量
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
}
也就是，ThreadLocal须要存放和获取的数据实际上绑定在Thread实例的成员变量threadLocals中，而且是ThreadLocal#set()方法调用的时候才进行懒加载的，能够结合上一节的内容理解一下，这里不展开。
八. 什么状况下ThreadLocal的使用会致使内存泄漏
其实ThreadLocal自己不存听任何的数据，而ThreadLocal中的数据其实是存放在线程实例中，从实际来看是线程内存泄漏，底层来看是Thread对象中的成员变量threadLocals持有大量的K-V结构，而且线程一直处于活跃状态致使变量threadLocals没法释放被回收。threadLocals持有大量的K-V结构这一点的前提是要存在大量的ThreadLocal实例的定义，通常来讲，一个应用不可能定义大量的ThreadLocal，因此通常的泄漏源是线程一直处于活跃状态致使变量threadLocals没法释放被回收。可是咱们知道，·ThreadLocalMap·中的Entry结构的Key用到了弱引用(·WeakReference<ThreadLocal<?>>·)，当没有强引用来引用ThreadLocal实例的时候，JVM的GC会回收ThreadLocalMap中的这些Key，此时，ThreadLocalMap中会出现一些Key为null，可是Value不为null的Entry项，这些Entry项若是不主动清理，就会一直驻留在ThreadLocalMap中。也就是为何ThreadLocal中get()、set()、remove()这些方法中都存在清理ThreadLocalMap实例key为null的代码块。总结下来，内存泄漏可能出现的地方是：
-
大量地(静态)初始化ThreadLocal实例，初始化以后再也不调用get()、set()、remove()方法。
-
初始化了大量的ThreadLocal，这些ThreadLocal中存放了容量大的Value，而且使用了这些ThreadLocal实例的线程一直处于活跃的状态。
ThreadLocal中一个设计亮点是ThreadLocalMap中的Entry结构的Key用到了弱引用。试想若是使用强引用，等于ThreadLocalMap中的全部数据都是与Thread的生命周期绑定，这样很容易出现由于大量线程持续活跃致使的内存泄漏。使用了弱引用的话，JVM触发GC回收弱引用后，ThreadLocal在下一次调用get()、set()、remove()方法就能够删除那些ThreadLocalMap中Key为null的值，起到了惰性删除释放内存的做用。
其实ThreadLocal在设置内部类ThreadLocal.ThreadLocalMap中构建的Entry哈希表已经考虑到内存泄漏的问题，因此ThreadLocal.ThreadLocalMap$Entry类设计为弱引用，类签名为static class Entry extends WeakReference<ThreadLocal<?>>。以前一篇文章介绍过，若是弱引用关联的对象若是置为null，那么该弱引用会在下一次GC时候回收弱引用关联的对象。举个例子：
public class ThreadLocalMain {
private static ThreadLocal<Integer> TL_1 = new ThreadLocal<>();
public static void main(String[] args) throws Exception {
TL_1.set(1);
TL_1 = null;
System.gc();
Thread.sleep(300);
}
}
这种状况下，TL_1这个ThreadLocal在主动GC以后，线程绑定的ThreadLocal.ThreadLocalMap实例中的Entry哈希表中原来的TL_1所在的哈希槽Entry的引用持有值referent(继承自WeakReference)会变成null，可是Entry中的value是强引用，还存放着TL_1这个ThreadLocal未回收以前的值。这些被”孤立”的哈希槽Entry就是前面说到的要惰性删除的哈希槽。
九. ThreadLocal的最佳实践
其实ThreadLocal的最佳实践很简单：
- 每次使用完ThreadLocal实例，都调用它的remove()方法，清除Entry中的数据。
调用remove()方法最佳时机是线程运行结束以前的finally代码块中调用，这样能彻底避免操做不当致使的内存泄漏，这种主动清理的方式比惰性删除有效。
十. 小结
ThreadLocal线程本地变量是线程实例传递和存储共享变量的桥梁，真正的共享变量仍是存放在线程实例自己的属性中。ThreadLocal里面的基本逻辑并不复杂，可是一旦涉及到性能影响、内存回收(弱引用)和惰性删除等环节，其实它考虑到的东西仍是相对全面并且有效的。
写在最后
- 第一：看完点赞，感谢您的承认；
- ...
- 第二：随手转发，分享知识，让更多人学习到；
- ...
- 第三：记得点关注，天天更新的！！！
- ...
- 1. ThreadLocal源码分析-黄金分割数的使用
- 2. 阿里大数据架构师分享：Spark源码解析
- 3. 黄金分割与构图
- 4. 阿里架构师教你如何使用ThreadLocal及原理分析
- 5. 黄金分割
- 6. ThreadLocal源码浅析
- 7. 黄金分割的金苹果 apple设计中的黄金分割
- 8. 阿里架构师手写Tomcat——Session源码解析
- 9. 阿里P8架构师浅析——MySQL的高并发优化
- 10. ThreadLocal源码分析
- 更多相关文章...
- • 互联网系统应用架构基础分析 - 红包项目实战
- • Docker 架构 - Docker教程
- • 使用阿里云OSS+CDN部署前端页面与加速静态资源
- • 互联网组织的未来：剖析GitHub员工的任性之源
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 跳槽面试的几个实用小技巧，不妨看看！
- 2. Mac实用技巧 |如何使用Mac系统中自带的预览工具将图片变成黑白色?
- 3. Mac实用技巧 |如何使用Mac系统中自带的预览工具将图片变成黑白色?
- 4. 如何使用Mac系统中自带的预览工具将图片变成黑白色?
- 5. Mac OS非兼容Windows软件运行解决方案——“以VMware & Microsoft Access为例“
- 6. 封装 pyinstaller -F -i b.ico excel.py
- 7. 数据库作业三ER图待完善
- 8. nvm安装使用低版本node.js(非命令安装)
- 9. 如何快速转换图片格式
- 10. 将表格内容分条转换为若干文档