多线程学习笔记九之ThreadLocal
简介
ThreadLocal顾名思义理解为线程本地变量，这个变量只在这个线程内，对于其他的线程是隔离的，JDK中对ThreadLocal的介绍：
This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its{@code get} or {@code set} method) has its own, independently initialized copy of the variable. {@code 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的set方法和get方法来存储和获得变量。
类结构
ThreadLocal类结构如下：
可以看到ThreadLocal有内部类ThradLocalMap,ThreadLocal存储线程局部对象就是利用了ThreadLocalMap数据结构，在下面的源码分析也会先从这里开始。
源码分析
ThreadLocalMap
ThreadLocalMap静态内部类Entry是存储键值对的基础，Entry类继承自WeakReference(为什么用弱引用在后面解释)，通过Entry的构造方法表明键值对的键只能是ThreadLocal对象，值是Object类型，也就是我们存储的线程局部对象，通过super调用父类WeakReference构造函数将ThreadLocal<?>对象转换成弱引用对象
ThreadMap存储键值对的原理与HashMap是类似的，HashMap依靠的是数组+红黑树数据结构和哈希值映射，ThreadMap依靠Entry数组+散列映射，ThreadLocalMap使用了Entry数组来保存键值对，Entry数组的初始长度为16，键值对到Entry数组的映射依靠的是int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);,通过ThreadLocal对象的threadLocalHashCode与(INITIAL_CAPACITY - 1)按位相与将键值对均匀散列到Entry数组上。
static class ThreadLocalMap {
// 键值对对象
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
//初始Entry数组大小
private static final int INITIAL_CAPACITY = 16;
//Entry数组
private Entry[] table;
//ThreadLocalMap实际存储键值对的个数
private int size = 0;
//数组扩容阈值
private int threshold; // Default to 0
//阈值为数组长度的2/3
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
/**
* Decrement i modulo len.
*/
private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
//构造一个ThreadLocalMap对象，并把传入的第一个键值对存储
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);
}
}
ThreadLocal作为做为键值对的键通过常量threadLocalHashCode映射到Entry数组,threadLocalHashCode初始化时会调用nextHashCode()方法，就是在nextHashCode的基础上加上0x61c88647,实际上每个ThreadLocal对象的threadLocalHashCode值相差0x61c88647，这样生成出来的Hash值可以较为均匀的散列到2的幂次方长度的数组中，具体可见这篇文章为什么使用0x61c88647
由于采用的是散列算法，就需要考虑Hash冲突的情况，HashMap解决Hash冲突的方法是链表+红黑树，ThreadLocalMap解决方法是linear-probe（线性探测），简单来说如果散列对应的位置已经有键值对占据了，就把散列位置加/减一找到符合条件的位置放置键值对。
// final常量，一旦确定不再改变
private final int threadLocalHashCode = nextHashCode();
/**
* The next hash code to be given out. Updated atomically. Starts at
* zero.
*/
private static AtomicInteger nextHashCode =
new AtomicInteger();
/**
* The difference between successively generated hash codes - turns
* implicit sequential thread-local IDs into near-optimally spread
* multiplicative hash values for power-of-two-sized tables.
*/
private static final int HASH_INCREMENT = 0x61c88647;
/**
* Returns the next hash code.
*/
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
//构造方法
public ThreadLocal() {
}
set(T value)
简要介绍完了内部类ThreadLocalMap后，set方法属于ThreadLocal,首先获得与线程Thread绑定的ThreadLocalMap对象，再将ThreadLocal和传入的value封装为Entry键值对存入ThreadLocalMap中。注意，ThreadLocalMap对象是在线程Thread中声明的：
ThreadLocal.ThreadLocalMap threadLocals = null;
public void set(T value) {
//获得当前线程对象
Thread t = Thread.currentThread();
//获得线程对象的ThreadLocalMap
ThreadLocalMap map = getMap(t);
// 如果map存在，则将键值对存到map里面去
if (map != null)
map.set(this, value);
//如果不存在，调用ThreadLocalMap构造方法存储键值对
else
createMap(t, value);
}
//返回线程t中声明的Thread
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
- set(ThreadLocal<?> key, Object value)
在ThreadLocalMap存在的情况下，调用ThreadLocal类的set方法存储键值对，set方法需要考虑散列的位置已经有键值对：如果已经存在的键值对的键当存入的键，覆盖键值对的值；如果键值对的键ThreadLocal对象已经被回收，调用replaceStaleEntry方法删除table中所有陈旧的元素（即entry的引用为null）并插入新元素。
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
//利用ThreadLocal的threadLocalHahsCode值散列
int i = key.threadLocalHashCode & (len-1);
//如果散列的位置不为空，判断是否是哈希冲突
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
//如果此位置的键值对的键与传入的键相同，覆盖键值对的值
if (k == key) {
e.value = value;
return;
}
//键值对的键为空，说明键ThreadLocal对象被回收，用新的键值对代替过时的键值对
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
//散列位置为空，直接存储键值对
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
get()
获得当前线程中保存的以ThreadLocal对象为键的键值对的值。首先获取当前线程关联的ThreadLocalMap,再获得以当前ThreadLocal对象为键的键值对，map为空的话返回初始值null，即线程局部变量为null，
public T get() {
//获取与当前线程绑定的ThreadLocalMap
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
//map不为空，获取键值对对象
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
private Entry getEntry(ThreadLocal<?> key) {
//散列
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
//判断散列位置的键值对是否符合条件:e.get()==key
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}
//线性探测寻找key对应的键值对
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)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
remove()
从ThreadLocalMap中移除键值对，一般在get方法取出保存的线程局部变量后调用remove方法防止内存泄露。
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
为什么ThreadLocalMap的键是WeakReferrence?
键值对对象Enry的键是ThreadLocal对象，但是使用WeakReferrence虚引用包装了的，虚引用相对于我们经常使用的String str = "abc"这种强引用来说对GC回收对象的影响较小，以下是虚引用的介绍：
WeakReference是Java语言规范中为了区别直接的对象引用（程序中通过构造函数声明出来的对象引用）而定义的另外一种引用关系。WeakReference标志性的特点是：reference实例不会影响到被应用对象的GC回收行为（即只要对象被除WeakReference对象之外所有的对象解除引用后，该对象便可以被GC回收），只不过在被对象回收之后，reference实例想获得被应用的对象时程序会返回null。
如果Entry的键使用强引用，那么我们存入的键值对即使线程之后不再使用也不会被回收，生命周期将变得和线程的生命周期一样。而使用了虚引用之后，作为键的虚引用并不影响ThreadLocal对象被GC回收，当ThreadLocal对象被回收后，键值对就会被标记为stale entry(过期的键值对),再下一次调用set/get/remove方法后会进行 ThreadLocalMap层面对过期键值对进行回收，防止发生内存泄漏。
注意：当我们使用了set方法存入局部变量后，如果不进行get/remove,那么过期的键值对无法被回收，所以建议在get取出存储变量后手动remove，可以有效防止内存泄漏。
总结
ThreadLocal实现了存储线程局部变量，ThreadLocal的实现并不是HashMap<Thread,Object>以线程对象为键，而是在线程内部关联了一个ThreadLocalMap用于存储键值对，键值对的键是ThreadLocal对象，所以ThreadLocal对象本身是不存储内容的，而是作为键与存储内容构成键值对。