ThreadLocal简介
Java中的ThreadLocal类给每个线程分配一个只属于该线程的变量副本，可以用来实现线程间的数据隔离，当前线程的变量不能被其他线程访问。
ThreadLocal使用
创建ThreadLocal变量
private ThreadLocal myThreadLocal = new ThreadLocal();
访问ThreadLocal变量
设置需要保存的值：
myThreadLocal.set("ThreadLocal value");
读取保存在ThreadLocal变量中的值：
String threadLocalVlaue = (String) myThreadLocal.get();
ThreadLocal范型
private ThreadLocal myThreadLocal = new ThreadLocal<String>()
初始化ThreadLocal的值
private ThreadLocal myThreadLocal = new ThreadLocal<String>(){
protected String initialVlaue(){
return "initial value";
}
};
源码分析
源码版本：
jdk7u80
最常用的方法就是get和set方法，所以先从这两个方法入手，分析下使用。
set(T value)
将当前的线程局部变量的副本的值设置为指定的值。子类一般不需要重写该方法，只需要使用initialValue方法去设置初始值。
public void set(T value) {
//获取当前线程
Thread t = Thread.currentThread();
//从当前线程中得到当前线程的ThreadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null)
//不为空的话，调用ThreadLocalMap的set方法设置值
map.set(this, value);
else
//ThreadLocalMap为null，还没有被初始化，创建新的map
createMap(t, value);
}
getMap(Thread t)
获取指定的线程t的ThreadLocalMap
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
createMap(t, value)
为当前线程t初始化一个ThreadLocalMap用来存储值，初始值是value。
在Thread类中ThreadLocal.ThreadLocalMap threadLocals = null;是用来存储当前线程对应的ThreadLocalMap，属于线程私有的。所以createMap方法使用t.threadLocals = new ThreadLocalMap(this, firstValue);来设置。
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
ThreadLocal用来把变量的副本存储到线程中，变量的副本就只能是当前线程私有，而在线程中是通过ThreadLocalMap来存储副本的，所以有必要了解下ThreadLocalMap是怎么实现的。
ThreadLocalMap
ThreadLocalMap是一个自定义的HashMap，用来存储线程本地变量的值，类似与Map。ThreadLocalMap内部是使用Entry对象来存储。
Entry
Entry继承了WeakReference，使用ThreadLocal作为key，value为ThreadLocal的值。
static class Entry extends WeakReference<ThreadLocal> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}
private static final int INITIAL_CAPACITY = 16;ThreadLocalMap的初始容量为16。
private Entry[] table;存放线程本地变量的数组。
private int size = 0; 线程本地变量的数目。
private int threshold 扩容的阈值。
扩容的阈值为指定长度的三分之二
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
//构造方法，当我们第一次使用的时候会构造一个新的ThreadLocalMap
ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
//存放线程本地变量的数组，初始容量16
table = new Entry[INITIAL_CAPACITY];
//得到存放Entry的数组下标
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
//在得出的位置处新建一个Entry对象
table[i] = new Entry(firstKey, firstValue);
//大小设为1
size = 1;
//设置阈值 16*2/3
setThreshold(INITIAL_CAPACITY);
}
使用给定的父map来构造一个ThreadLocalMap
private ThreadLocalMap(ThreadLocalMap parentMap) {
//父map中存放的线程本地变量数据
Entry[] parentTable = parentMap.table;
//父map的长度
int len = parentTable.length;
//设置阈值
setThreshold(len);
//新建长度为len的Entry数组
table = new Entry[len];
//循环把父map的数组的元素放到新数组中去，中间需要重新计算数组下标。
for (int j = 0; j < len; j++) {
Entry e = parentTable[j];
if (e != null) {
ThreadLocal key = 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++;
}
}
}
}
根据key获取Entry
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时候
//key ThreadLocal对象
//i 计算出来的数组下标
//e 在i处的entry
private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
while (e != null) {
//获取key
ThreadLocal k = e.get();
//找到key，返回e
if (k == key)
return e;
//key为null，找不到，清除掉
if (k == null)
expungeStaleEntry(i);
else
//key不为null，计算下一个数组下标
i = nextIndex(i, len);
//返回下一个entry
e = tab[i];
}
return null;
}
//存放指定的key和value
private void set(ThreadLocal key, Object value) {
//当前存放的数组
Entry[] tab = table;
//数组长度
int len = tab.length;
//根据key获取存放的数组下标
int i = key.threadLocalHashCode & (len-1);
//从第i个元素开始挨个遍历
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
//获取到i处的key
ThreadLocal k = e.get();
//i处的key和要存放的key相等，将原来的值替换成新的值，返回。
if (k == key) {
e.value = value;
return;
}
//i处key为null
if (k == null) {
//替换原来的Entry
replaceStaleEntry(key, value, i);
return;
}
}
//不存在key，新建一个Entry
tab[i] = new Entry(key, value);
//size加1
int sz = ++size;
//不能移除一些旧的entry并且新的size已经大于等于阈值了，需要重新扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
//rehash()
private void rehash() {
//首先清除旧的entry
expungeStaleEntries();
// size大于等于阈值的四分之三，将容量扩展为两倍
if (size >= threshold - threshold / 4)
resize();
}
ThreadLocalMap内部的Entry的get和set基本就这些，接下来继续看ThreadLocal的get方法
public T get()
public T get() {
//获取当前线程
Thread t = Thread.currentThread();
//获取当前线程的ThreadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
//map为空，设置初始值，并返回
return setInitialValue();
}
private T setInitialValue()
private T setInitialValue() {
//这里初始值为null
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
remove()
移除当前线程的ThreadLocalMap中的值
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
总结一下get和set方法
get方法：
首先获取到当前线程，然后获取当前线程内部的ThreadLocalMap，如果map不为空，就查找到Entry中的值，返回；如果map为空，设置初始值，并返回。
set方法：
首先获取到当前线程，然后获取当前线程内部的ThreadLocalMap，如果map不为空，直接使用Entry的set设置值，此方法会替换原来的值；如果map为空，说明没有使用过，新建一个map并使用当前线程和指定的值初始化。
