1.大概去哪里看
ThreadLocal 其根本实现方法，是在Thread里面，有一个ThreadLocal.ThreadLocalMap属性
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocalMap 静态内部类维护了一个Entry 数组
private Entry[] table;
查看Entry 源码，它维护了两个属性，ThreadLocal 对象 与一个Object
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
那么，这几项似乎可以这么串下来： Thread. currentThread().threadLocals. table｛当前线程，的ThreadLocalMap对象，的Entry数组｝（忽略访问权限的事儿）
------------------------------------------------我是分割线------------------------------------------------
2.代码实现分析
ThreadLocal 提供set(),get()方法，用于数据的写入与读取。数据的存储与获取的位置，即
Thread. currentThread().threadLocals. table ｛当前线程，的ThreadLocalMap对象，的Entry数组｝
public void set(T value) {
Thread t = Thread.currentThread();//获取当前线程t
ThreadLocalMap map = getMap(t);//获取threadLocals 对象
if (map != null)
map.set(this, value);//调用 ThreadLocalMap 的set方法向 threadLocals 中写入一条数据
else
createMap(t, value);//如果threadLocals 为null 则为当前线程t 创建一个map，并插入数据
}
map.set(this, value);注意，这里，传入的第一个参数为this 即 ThreadLocal 对象自身，
假如我们声明了一串代码：
private static ThreadLocal<String> threadLocal = new ThreadLocal<String>();
然后我们又执行了 threadLocal.set(“string 1234”);
那么，在Thread. currentThread().threadLocals. table 中，应该有这么一个Entry :ThreadLocal指向threadLocal，value 为 “string 1234”
分析源码（这里，所有的源码都来自于jdk1.7.0_71）：
private void set(ThreadLocal<?> key, Object value) {
// We don‘t use a fast path as with get() because it is at
// least as common to use set() to create new entries as
// it is to replace existing ones, in which case, a fast
// path would fail more often than not.
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();
if (k == key) {
e.value = value;
return;
}
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
分析两处：
1. int i = key.threadLocalHashCode & (len-1);
根据当前的ThreadLocal 的threadLocalHashCode 跟 ThreadLocalMap.table的长度-1 ，按位与，获得目标索引值 i ， 如果tab[i] 为空的话，将会在 tab[i] 处插入一个Entry ；
2. for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)])
如果如果tab[i] 不为空，则调用i = nextIndex(i, len) 将i值进行+1或者置为0，然后判断e是否为null 如果e!=null 判断e 中的 ThreadLocal对象，跟传入的ThreadLocal 对象，是否为同一个对象。如果是同一个对象，则对e的value 进行重新赋值。如果在遍历的过程中发现某个e的ThreadLocal 对象为空，则将Entry(threadLocal,” string 1234”) 设置在此时的tab[i]处。
（如果一开始进来的时候e 为null 即 tab[i]==null 。是不会走for循环的，会直接把Entry(threadLocal,” string 1234”) 赋值到table[i]）;
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
分析，为什么会有i = nextIndex(i, len) 这样的设定。
执行int i = key.threadLocalHashCode & (len-1);的时候，很可能不同的key.threadLocalHashCode得到了相同的 i 值，那么，就从 i 开始，遍历table对象，找到一个可以放置Entry(threadLocal,” string 1234”) 的位置，
比如:
System.out.println(626627285 & 16-1);//5
System.out.println(626627317 & 16-1);//5
System.out.println(626627573 & 16-1);//5
这三个，获取到的i值，都为5（当然实际用到的hashCode的算法不是这样的，不会产生这么接近的数）。
在同一个线程中，626627285先set(value1)了，得到5，table[5]为空，那就填进去 table[5]=new Entry(626627285,value1);626627317接着set(value2)，算出来i=5,但是table[5]已经有人占了，那就只能看table[6]有没有空闲位置，一看table[6]==null,好，就放这儿了table[6]=new Entry(626627317,value2);626627573接着set(value3)，算出来i=5,但是table[5]已经有人占了，那就只能看table[6]有没有空闲位置，一看table[6]也被占了，再看table[7]==null,好，就放这儿了table[7]=new Entry(626627573,value3)假如有个线程算出来i=15 但是table[15]!=null,需要向后找空闲位置，table[16]是越界的，nextIndex返回0，从table[0]开始找
下面这串代码，维护了table 的长度，避免了遍历了一圈table 却找不到 table[i]==null 的情况，即保证table的某些索引处肯定为null，因为还没填满的时候就已经扩容了。
if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash();
------------------------------------------------我是分割线------------------------------------------------
下面分析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;
}
}
return setInitialValue();
}
1. 获取当前线程的threadLocals 并传入 ThreadLocal 对象，获取对应的值。
2. 如果当前线程的threadLocals 为null ，则为当前线程t 创建一个map，并插入数据setInitialValue ()=null，并返回null
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;
}
分析map.getEntry(this)
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
return getEntryAfterMiss(key, i, e);
}
这里看到，也是先使用 int i = key.threadLocalHashCode & (table.length - 1); 得到一个索引值，然后去table获取 Entry对象，得到几种结果：
1. e!=null && e.get()!=key 因为是通过“int i = key.threadLocalHashCode & (table.length - 1);”获取的索引值，不同的ThreadLocal 对象，可能获取到相同的索引值，所以，这种情况是存在的。
2. e==null 当前的ThreadLocal 对象 压根儿没有set值。
3. e!=null&&e.get()==key 如果Entry对象的key值与当前传入的ThreadLocal 对象，是同一个对象，则返回e 然后在 get()方法中，返回e.value;
以上 1、2 两种情况的时候，会执行getEntryAfterMiss(key, i, e);
在同一个线程中，626627285、626627317、626627573算到的i值均为5，但是只有626627285==table[5].get(),626627317、626627573这两个，都需要走getEntryAfterMiss(key, i, e)方法了
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;
}
1. 如果初始出入的e==null 则不进入while 循环直接返回null
2. 在while循环里面，如果e.get()==key 即，e 的Entry对象的key值与当前传入的ThreadLocal 对象，是同一个对象，则返回e 。
3. 如果e.get()==null 的情况下，先将table[i]置为空，然后向后遍历直到
table[nextIndex(i, len)]==null，将table[nextIndex(i, len)]!=null的对象，重新写入table中。
4. k!=key&&key!=null的时候，则调用i = nextIndex(i, len) 将i值进行+1或者置为0，然后判断e是否为null 如果e!=null 判断e 中的 ThreadLocal对象，跟传入的ThreadLocal 对象，是否为同一个对象。如果是同一个对象，返回当前的 Entry对象，如果遇到了e==null的时候，还没有找到目标的Entry ，就返回null 。
为什么找到e==null的地方就可以跳出了呢？
如果如果tab[i] 不为空，则调用i = nextIndex(i, len) 将i值进行+1或者置为0，然后判断e是否为null 如果e!=null 判断e 中的 ThreadLocal对象，跟传入的ThreadLocal 对象，是否为同一个对象。如果是同一个对象，则对e的value 进行重新赋值。如果在遍历的过程中发现某个e的ThreadLocal 对象为空，则将Entry(threadLocal,” string 1234”) 设置在此时的tab[i]处。
这里，插入的Entry(threadLocal,” string 1234”) ，要么，在初始的i 处，要么，往后+1顺延，不会跳过某个索引值，然后进行赋值。所以，当table[i]==null的时候，已经可以不继续找了。
------------------------------------------------我是分割线------------------------------------------------
3 还有一点我觉得很重要的东西
分析到这里的时候，我们应该有发现一个很重要的问题，即：
int i = key.threadLocalHashCode & (table.length - 1);
获得的i值是固定的吗？
很明显不是的，因为table 会扩容，table.length 会变，得到的i值也是不一样的：
System.out.println(626627285 & 16-1);//5 System.out.println(626627285 & 32-1);//21
这样的话，table[i]岂不是会出错？
然后，仔细阅读源码，在进行扩容的时候，会调用resize()方法：
private void resize() {
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();
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++;
}
}
}
setThreshold(newLen);
size = count;
table = newTab;
}
在resize() 方法中，我们看到，这里新建了一个长度为原本的长度2倍的Entry数组，然后，将原Entry数组的所有元素，
挨个儿的重新计算索引 int h = k.threadLocalHashCode & (newLen - 1);
然后赋值原有的Entry 到新的Entry 数组中，这样，就保证了数组扩容之后，获取到的 i 值，是适配新数组的正确的值。
继续拿626627285、626627317、626627573举例，这三个，在数组扩容为长度=32的时候，算出来的i值，均为21，那么他们将会是这么算的：oldTab[5]!=null oldTab[5].get=626627285 算得i=21，table[21]==null table[21]=oldTab[5];oldTab[6]!=null oldTab[6].get=626627317 算得i=21，table[21]!=null table[22]==null table[22]=oldTab[6];oldTab[7]!=null oldTab[7].get=626627573 算得i=21，table[21]!=null tanle[22]!=null table[23]==null table[23]=oldTab[7];
------------------------------------------------我是分割线------------------------------------------------
以上，是我个人查看jdk源码，分析出来的ThreadLocal得实现原理与工作原理。欢迎大家批评讨论斧正。谢谢