ThreadLocal使用场景
ThreadLocal是绑定在Thread上的变量，生命周期与Thread相同。通常用于线程内数据共享。
例如线程内接口调用追踪，我们会在第一个调用处生成一个ID，在接下来的接口中，获取这个ID，打印出调用链，那么就可以用ThreadLocal很方便的传递这个调用链ID，而不影响其他线程的调用链ID的传递与生成。
源码解读
我们通常使用ThreadLocal的set，get和remove方法。
set处理代码片段：
public void set(T value) {
//获取当前线程
Thread t = Thread.currentThread();
//获取当前线程的ThreadLocalMap
ThreadLocalMap map = getMap(t);
//map不为空，则将当前变量与当前线程绑定
if (map != null)
map.set(this, value);
else
//为空，则创建map
createMap(t, value);
}
接下来看看createMap，源码如下
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//初始化一个entry数组
table = new Entry[INITIAL_CAPACITY];
//计算所在位置
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
//构造entry，并放入相应的位置
table[i] = new Entry(firstKey, firstValue);
//设置当前table元素个数
size = 1;
//设置容量调整阈值
setThreshold(INITIAL_CAPACITY);
}
若当前线程中有ThreadLocalMap，则将变量塞到map中去。源码如下：
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
//循环获取entry
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
//若变量已存在且没被gc，则更新值
if (k == key) {
e.value = value;
return;
}
//找到位置了，删除无用的entry，将该entry放入相应的位置
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
//变量不存在，则放入map
tab[i] = new Entry(key, value);
//table的元素个数+1
int sz = ++size;
//是否需要扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
其中replaceStaleEntry方法如下，这是一坨复杂的逻辑，主要完成的就是清除过期的entry，然后将新的entry放入进来：
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
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();
if (k == key) {
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
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;
}
// If key not found, put new entry in stale slot
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
// If there are any other stale entries in run, expunge them
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
至此，set完成。
接下来看get源码：
public T get() {
Thread t = Thread.currentThread();
//获取当前线程的ThreadLocalMap
ThreadLocalMap map = getMap(t);
//Map 不为空，遍历map，找到相应的值，
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//Map为空，或者map里没有相应的值，则取初始值
return setInitialValue();
}
每个线程持有的ThreadLocalMap，实际上操作的都是Map的Entry。看下entry代码
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
从源码中可以看出，线程本地变量的隔离机制如下：
每个线程Thread都会有一个ThreadLocalMap的成员变量。Map的key值是定义的ThreadLocal实例。所有的线程里Map的ThreadLocal都指向同一个地址，只是每个线程的value值不一样。即同一个变量在每个线程里的值都不一样。到达了线程隔离的效果。
