ThreadLocal是Thread的局部变量，用于多线程编程，接下来看一个简单的例子：
public class Example {
private final ExecutorService service = Executors.newFixedThreadPool(2);
private final ThreadLocal<String> threadLocal = new ThreadLocal<>();
@Test
public void main() {
threadLocal.set("main");
System.out.println(threadLocal.get());
service.execute(runnable1);
service.execute(runnable2);
}
private Runnable runnable1 = new Runnable() {
@Override
public void run() {
threadLocal.set(Thread.currentThread().getName());
System.out.println(threadLocal.get());
}
};
private Runnable runnable2 = new Runnable() {
@Override
public void run() {
System.out.println(threadLocal.get());
}
};
}
/*******************运行结果
main
pool-1-thread-1
null
*******************/
从上面的例子中可以看到ThreadLocal的全局对象在主线程中设置为main字符串，子线程如果不设置值默认为null，设置值则有自己独立的值。查看其构造函数：
public class ThreadLocal<T> {
public ThreadLocal() {
}
}
空构造函数，基本什么都没做，接着看它的成员方法set/get：
public void set(T value) {
// 当前线程
Thread t = Thread.currentThread();
// 获取当前线程的threadLocals成员
ThreadLocalMap map = getMap(t);
// map不为空，直接set
if (map != null)
map.set(this, value);
else
// map为空执行初始化
createMap(t, value);
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
public T get() {
// 当前线程
Thread t = Thread.currentThread();
// 获取成员
ThreadLocalMap map = getMap(t);
// 成员不为null
if (map != null) {
// 获取map中的entry对象
ThreadLocalMap.Entry e = map.getEntry(this);
// 对象不为null，返回值
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
// 初始化成员，并赋值为null
return setInitialValue();
}
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;
}
从上面可以看到，这是一个类似hashMap的操作，在set的时候通过key存储数据，在get的时候使用key来获取存储的内容，接下来看ThreadLocalMap这个内部类：
static class ThreadLocalMap {
// 核心类Entry继承于WeakReference，弱引用ThreadLocal，强引用value
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
// 类似hashmap，容量为2^4
private static final int INITIAL_CAPACITY = 16;
// 以数组的形式保存
private Entry[] table;
// 扩容阈值
private int threshold;
// 默认构造函数
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
// 初始化table
table = new Entry[INITIAL_CAPACITY];
// 根据key的hash值计算坐标值
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
// 以Entry对象保存key和value值
table[i] = new Entry(firstKey, firstValue);
// 容量初始化为1
size = 1;
// 设置扩容阈值为16*2/3 = 10
setThreshold(INITIAL_CAPACITY);
}
// 类似数组的复制，初始化ThreadLocalMap
private ThreadLocalMap(ThreadLocalMap parentMap) {
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);
int h = key.threadLocalHashCode & (len - 1);
while (table[h] != null)
h = nextIndex(h, len);
table[h] = c;
size++;
}
}
}
}
private Entry getEntry(ThreadLocal<?> key) {
// 根据key的hash值计算坐标
int i = key.threadLocalHashCode & (table.length - 1);
// 获取table当前坐标的内容
Entry e = table[i];
// 如果e不为null且key值相等，返回
if (e != null && e.get() == key)
return e;
else
// 查找对象
return getEntryAfterMiss(key, i, e);
}
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
// 如果e不为null，说明key不一样
while (e != null) {
// 获取当前key
ThreadLocal<?> k = e.get();
// key值相等，返回
if (k == key)
return e;
// tab[i]位置的key值为null
if (k == null)
// 清除i位置的内容，并对Entry数组进行一个重拍
expungeStaleEntry(i);
else
// i右移一位
i = nextIndex(i, len);
// 获取右移一位的内容
e = tab[i];
}
// 没有找到对象，返回null
return null;
}
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// 消除该位置的内容
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// Rehash until we encounter null
Entry e;
int i;
// 从staleSlot+1开始，tab[i]==null的时候结束
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
// 获取i位置的ThreadLocal
ThreadLocal<?> k = e.get();
// 如果为null，则清空该对象
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
// 计算一个坐标值
int h = k.threadLocalHashCode & (len - 1);
// 如果它的坐标值不等于i，说明它可能是移位到这里来的
if (h != i) {
// 将该位置清空
tab[i] = null;
// 如果h位置已经有数据了，那么使用开放寻址法-线性寻址法找到一个空位，并赋值
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
// 根据hash值计算坐标i
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
// 如果key相同，更新value
if (k == key) {
e.value = value;
return;
}
// 如果当前位置的key为null
if (k == null) {
// 替换过期的 Entry
replaceStaleEntry(key, value, i);
return;
}
}
// 若数组下标为 i 的位置为空，将要存储的元素放到 i 的位置
tab[i] = new Entry(key, value);
int sz = ++size;
// 若清理过期的Entry数量为0，且数组的大小达到阈值，执行 rehash 操作
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;
// 从 staleSlot 开始向前遍历，若遇到过期的槽（Entry 的 key 为空），更新 slotToExpunge
// 直到 Entry 为空停止遍历
int slotToExpunge = staleSlot;
// prevIndex是向左移动一位（-1）
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
// 找到一个空值，并赋值给slotToExpunge
if (e.get() == null)
slotToExpunge = i;
// 从 staleSlot 开始向后遍历，若遇到与当前 key 相等的 Entry，更新旧值，并将二者换位置
// 目的是把它放到「应该」在的位置
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
// 如果key相同，更新value，并交换staleSlot与当前位置
if (k == key) {
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
// 如果左右找到的是同一个值，更新slotToExpunge
if (slotToExpunge == staleSlot)
slotToExpunge = i;
// 删除或者重新计算
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
// 如果反向查找没有找到什么，那么选取第一个
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
// 若未找到 key，说明 Entry 此前并不存在，新增
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
// 删除之前的内容
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
从上面可以看到，ThreadLocalMap用数组存储Entry数据，使用线性寻址法来应对hash冲突。
ThreadLocal引发的内存泄漏
ThreadLocal通常是用作成员变量或者静态变量来使用，存放在堆中，如果是使用new Thread()来创建线程，Thread会持有一个ThreadLocalMap的强引用，同时ThreadLocalMap中的Entry会持有ThreadLocal的一个弱引用，在线程执行完毕的时候，线程结束，栈内存被回收，Thread对ThreadLocalMap的引用断开，GC的时候，弱引用也会断开，整个ThreadLocalMap都会被回收。
然而在使用线程池的时候，线程是一直存活的，GC的时候，Entry对ThreadLocal的弱引用会断开，Entry的key为null，但value不为null，此时如果不对ThreadLocalMap进行清理，那么Entry中的value对象就会发生内存泄漏。解决方法也很简单，在线程运行完的时候执行remove即可。
