ThreadLocal 工作原理、部分源码分析
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) 这样的设定。（2017-01-04 ps:这是一种hash防冲撞的方案）
执行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得实现原理与工作原理。欢迎大家批评讨论斧正。谢谢
