ThreadLocal是什么
顾名思义，ThreadLocal为线程局部变量
使用场景
JDBC的连接connection对象都是非线程安全对象。所以在web环境下，使用一个线程处理一个请求的时候，需要从数据库连接池中取出connection对象，但是为了保证connection对象的线程安全性，很简单的一个方案就是将它线程私有化，这个时候就需要用到我们的线程局部变量ThreadLocal。
从上述例子中我们可以看出来ThreadLocal这个类的使用方法，就是将一个共享的对象绑定到一个线程上去，从而实现线程安全。
源码分析
首先分析属性和相关方法
/**
* 初始hashcode的值
*/
private static AtomicInteger nextHashCode =
new AtomicInteger();
/**
* 哈希增加值
*/
private static final int HASH_INCREMENT = 0x61c88647;
/**
* Returns the next hash code.
*/
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
这几个属性后面会用到检测hash算法是否一致。
分析一下核心的set方法。ThreadLocal的set方法是通过代理给它的内部类ThreadLocalMap实现的。
public void set(T value) {
Thread t = Thread.currentThread();
// Thread类中存在一个ThreadLocalMap的属性，该方法就相当于t.threadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null)
// 代理到内部类ThreadLocalMap
map.set(this, value);
else
//当map为空的时候需要创建一个map
createMap(t, value);
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
于是对于ThreadLocal的分析就转换为对内部类ThreadLocalMap的分析。首先对ThreadLocalMap相关属性和构造方法进行分析
static class ThreadLocalMap {
//该类继承了WeakReference是方便垃圾回收，在底层map扩容之前进行entry的回收，减
//少扩容的概率,提高性能
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
//初始容量
private static final int INITIAL_CAPACITY = 16;
/**
* 底层数组
*/
private Entry[] table;
/**
* map中entry的个数
*/
private int size = 0;
/**
* 阈值，超过这个阈值之后就需要进行扩容
*/
private int threshold; // Default to 0
/**
* 阈值是底层数组长度的2/3
*/
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
/**
* 计算下一个索引，hash算法定位失败的时候（也就是该索引位置存在元素）
*/
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
/**
* 上一个位置索引，hash算法定位失败的时候（也就是该索引位置存在元素）
*/
private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
/**
* 根据key和value构建ThreadLocaMap
*/
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
/**
* 根据父容器构造ThreadLocalMap
*/
private ThreadLocalMap(ThreadLocalMap parentMap) {
//根据父容器创建一个ThreadLocalMap
Entry[] parentTable = parentMap.table;
int len = parentTable.length;
setThreshold(len);
table = new Entry[len];
//复制遍历
for (int j = 0; j < len; j++) {
Entry e = parentTable[j];
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);
//该句相当于 hashcode % len但是&运算更加高效
int h = key.threadLocalHashCode & (len - 1);
//hash算法定位失败，找下一个索引
while (table[h] != null)
h = nextIndex(h, len);
table[h] = c;
size++;
}
}
}
}
}
set方法的分析
private void set(ThreadLocal<?> key, Object value) {
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;
}
//处理key为null的情况
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
//通过hash算法定位的数组索引位置为null，直接创建一个entry放入即可
tab[i] = new Entry(key, value);
int sz = ++size;
//首先清理槽，底层数组entry的个数还是大于等于3/4*threshold就需要扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
// 首先向前扫描，记录最前端的value为null的entry，
// 之后清理槽的时候将它们全部清理掉
int slotToExpunge = staleSlot;
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i;
// 向后扫描
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
// 如果找到了对应的key，首先替换value，然后将两个槽替换
// 最后需要清理槽
if (k == key) {
//替换value
e.value = value;
//将当前位置的槽和最初hash算法定位到的槽替换
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
// 该句话代表，索引i位置前的entry没有value为null的
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，现将value赋值为null，之后在重新创建一个
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
// 不想等证明中间肯定有key == null的slot就需要清理
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// 清理value和entry，此处为何不清理key呢？
// 相信了解weakreference的朋友都知道，weakreference对象在最近一次
// 垃圾收集中就会被清理了，不需要我们手动去清理。
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// Rehash until we encounter null
Entry e;
int i;
//从当前索引位置开始，清理掉key为null的entry
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
//清理key == null的slot
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
// 如果key不为null，就需要计算出索引和当前索引是否一致
int h = k.threadLocalHashCode & (len - 1);
//不一致就需要进行清理，并且同时将entry覆盖掉不为null的slot
if (h != i) {
tab[i] = null;
//找到不为null的slot
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
//返回不为null的slot的索引
return i;
}
//该方法实质是通过expungeStaleEntry清理slot
private boolean cleanSomeSlots(int i, int n) {
boolean removed = false;
Entry[] tab = table;
int len = tab.length;
// 使用一个循环，折半的方式清理slot
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); //折半，相当于 n /= 2
return removed;
}
private void rehash() {
//检查清理
expungeStaleEntries();
// 当size大于等于3/4阈值的时候扩容
if (size >= threshold - threshold / 4)
resize();
}
/**
* 创建一个数组长度为原来两倍的数组，在进行复制和粘贴
* 在这个过程中和hashmap不同的是，假如key也为null就需要清理
*/
private void resize() {
//创建一个2倍长度的新数组
Entry[] oldTab = table;
int oldLen = oldTab.length;
int newLen = oldLen * 2;
Entry[] newTab = new Entry[newLen];
int count = 0;
// 循环复制粘贴
for (int j = 0; j < oldLen; ++j) {
Entry e = oldTab[j];
if (e != null) {
ThreadLocal<?> k = e.get();
// 清理掉key为null的slot
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++;
}
}
}
//循环复制完毕，设置阈值，设置map中元素个数，将table的引用指为新创建的数组
setThreshold(newLen);
size = count;
table = newTab;
}
/**
* Expunge all stale entries in the table.
*/
private void expungeStaleEntries() {
Entry[] tab = table;
int len = tab.length;
for (int j = 0; j < len; j++) {
Entry e = tab[j];
// value为null的slot进行清理
if (e != null && e.get() == null)
expungeStaleEntry(j);
}
}
set方法共有三种情况：1.如果对应的slot为null就直接创建一个entry放入即可； 2.如果key存在直接替换 3.当key为null，就需要遍历和判断是否存在对应key，如果存在替换value，替换slot，如果不存在直接创建一个新entry覆盖。在此期间，还需要清理数组中key为null，和hash算法不一致的entry。之后在map中增加了一个之后还需要检查是否需要扩容，但是与HashMap不同的是，它首先为进行一个slot的清理，在进行检查。
set方法分析完毕，之后分析比较容易的get方法
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//map为空的状况
return setInitialValue();
}
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e;
else
//处理key丢失的情况
return getEntryAfterMiss(key, i, e);
}
/**
* 处理key丢失的情况，
* 总体思想就是通过从当前位置开始循环遍历，将下一个entry的key和当前key进
* 形比较，如果想等就返回，不想等就找下一个索引，再此期间还需要进行entry的
* 清理。如果最后没有找到丢失的key就返回null
*/
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
//循环遍历查找
while (e != null) {
ThreadLocal<?> k = e.get();
if (k == key)
return e;
if (k == null)
//该方法是处理清理ThreadLocalMap的slot
expungeStaleEntry(i);
else
//没找到，下一个位置查找
i = nextIndex(i, len);
e = tab[i];
}
// 循环一周没找到key，返回null
return null;
}
//创建一个初始值放入到map中
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
//可以自行覆盖该方法
protected T initialValue() {
return null;
}
get方法通过双重保险机制。第一重保险就是通过当前线程获取ThreadLocalMap，第二重保险就是通过ThreadLocal自身对象获取value。获得value的的时候同样是使用了代理机制，将get方法代理到ThreadLocalMap中来，ThreadLocalMap调用getEntry方法，该方法如果找不到对应的key就调用key丢失会调用的方法。该方法总体来说就是查找key，如果不存在就返回null，存在就返回对应的value。
ThreadLocal内存泄漏
通过上诉的分析我们明白了ThreadLocal的原理大致如下图所示：
对着原理图来分析一下ThreadLocal内存泄漏产生的原因：
首先ThreadLocalMap用ThreadLocal对象作为key，而ThreadLocal对象是weakreference对象，那么在下一次GC的时候会回收Map中为null的key对象，而此时存在另外一条强引用链，这一条链就是CurrentThread ref–>ThreadLocalMap–>value，由于这一条强引用链的存在导致value对象无法被回收。我们在上面分析得知set和get方法，会检查key是否为null，并且回收key == null的Entry，但是set和get方法的检查只能减少内存泄漏的概**率，而无法确保不发生内存泄漏。
所以，ThreadLocal的正确使用习惯是，在不使用该对象之后调用该对象之后调用remove方法。**