一、样例及原理
// 成员变量ThreadLocal<Object> TL = new ThreadLocal<>();@Testpublic void testTL(){ TL.set(new Object()); TL.get();}
ThreadLocal以一种空间换工夫的思维（变量在不同的线程开拓正本），解决并发问题。
线程持有名为threadLocals的援用，指向一个ThreadLocalMap
- ThreadLocalMap的实质是一个Entry对象数组
ThreadLocalMap解决hash抵触的形式与HashMap的形式不同（链、树），ThreadLocalMap它会从落点桶地位程序查找。
如：hash取余计算出落点桶是5，但地位5曾经有其它entry，那么会尝试放入桶6……
- key是ThreadLocal对象自身，由Entry对象以弱援用的形式指向key
采纳弱援用的形式，是为了帮忙回收，防内存溢出（源码中有扫描逻辑）。
如果持有ThreadLocal的对象被回收了（样例中的成员变量不存在了），意味着指向ThreadLocalMap的key的强援用不存在了，那么弱援用被GC扫描到时也会被回收。
- value则是要存储的对象
二、set()
public void set(T value) { Thread t = Thread.currentThread(); // 获取线程的threadLocals变量 ThreadLocalMap map = getMap(t); if (map != null) // == 2.找到Entry数组中的entry，并赋值 map.set(this, value); else // == 1.创立ThreadLocalMap，并赋值 // - 线程有个threadLocals变量，这个变量指向Entry数组（一个Thread关联的多个ThreadLocal对象，默认16）； // - Entry对象是弱援用的 createMap(t, value);}1.创立ThreadLocalMap
java.lang.ThreadLocal#createMapvoid createMap(Thread t, T firstValue) { // ## 调用ThreadLocalMap的构造函数，将以后的threadLocal作为key // 最终赋值给线程的threadLocals变量 t.threadLocals = new ThreadLocalMap(this, firstValue);}// 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; // 扩大因子，size * 2/3 setThreshold(INITIAL_CAPACITY);}要害类、属性
# Thread类ThreadLocal.ThreadLocalMap threadLocals = null;# ThreadLocal类static class ThreadLocalMap { private Entry[] table; // table的size，也就是本线程对应的ThreadLocal数量 private int size = 0; // 弱援用：一旦发现了只具备弱援用的对象，不论以后内存空间足够与否，都会回收它的内存 // 如果不应用弱援用，那么当持有value的强援用开释掉后，当线程没有回收开释时， // threadLocalMap会始终持有ThreadLocal以及value的强利用，导致value不可能被回收，从而造成内存透露。 static class Entry extends WeakReference<ThreadLocal<?>> { Object value; Entry(ThreadLocal<?> k, Object v) { super(k); value = v; } }}2.ThreadLocalMap#set
private void set(ThreadLocal<?> key, Object value) { Entry[] tab = table; int len = tab.length; // 依据hash值和len找落点 int i = key.threadLocalHashCode & (len-1); // 线性查找 for (Entry e = tab[i]; e != null; // 循环中做线性查找，落点i在数组中挪动（如果曾经是数组的最初一个地位，会从地位0持续查找） e = tab[i = nextIndex(i, len)]) { // 获取以后地位的key->ThreadLocal ThreadLocal<?> k = e.get(); // == 1.1、Entry数组中找到了对应的ThreadLocal，赋值替换 if (k == key) { e.value = value; return; } // ## 2、原地位的entry为空（stale-生效），替换 if (k == null) { replaceStaleEntry(key, value, i); return; } } // == 1.2、Entry数组中没找到，新建Entry，放入空槽i（经验下面的循环后，i为最近的空位）地位 tab[i] = new Entry(key, value); int sz = ++size; // -- a、满足扩容条件(条件：无奈清理 && 达到阈值)，做扩容操作 if (!cleanSomeSlots(i, sz) && sz >= threshold) // -- b、扩容 rehash();}a、桶清理
private boolean cleanSomeSlots(int i, int n) { boolean removed = false; Entry[] tab = table; int len = tab.length; do { i = nextIndex(i, len); Entry e = tab[i]; // entry不为空，但entry的key为空（## 弱援用被回收，前提条件是持有ThreadLocal的对象被回收，见下图） if (e != null && e.get() == null) { n = len; // 执行清理操作，返回值设置为true removed = true; // == 清理有效entry i = expungeStaleEntry(i); } } // 通过size（理论的Entry对象个数，也就是线程持有的ThreadLocal个数）二进制右移来确定循环次数 // 举例：2->0循环2次；8->0循环4次 while ( (n >>>= 1) != 0); return removed;}看下理论的清理办法
private int expungeStaleEntry(int staleSlot) { Entry[] tab = table; int len = tab.length; // 分明以后的有效节点 tab[staleSlot].value = null; tab[staleSlot] = null; size--; Entry e; int i; for (i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { ThreadLocal<?> k = e.get(); // -- 帮忙清理其它有效节点 if (k == null) { e.value = null; tab[i] = null; size--; } // -- 帮忙k找到理论的桶 // 原来在i地位，但当年抉择i地位是无奈之举——hash抵触，理论是h地位； // 当初有机会把它落在该落的h地位，i地位清空 else { int h = k.threadLocalHashCode & (len - 1); if (h != i) { tab[i] = null; // 好吧，理论落点h也被占用了，只能持续找到新的h位 while (tab[h] != null) h = nextIndex(h, len); tab[h] = e; } } } return i;}b、rehash()
private void rehash() { // 理论的清理办法，曾经剖析过 expungeStaleEntries(); // Use lower threshold for doubling to avoid hysteresis if (size >= threshold - threshold / 4) // 扩容 resize();}## 扩容 && 旧桶对象迁新桶private void resize() { Entry[] oldTab = table; int oldLen = oldTab.length; // 2倍扩容 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); // hash抵触，找最近空位 while (newTab[h] != null) h = nextIndex(h, newLen); newTab[h] = e; count++; } } } setThreshold(newLen); size = count; table = newTab;}原地位的entry为空（stale-生效），替换
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; // Start expunge at preceding stale entry if it exists if (slotToExpunge == staleSlot) slotToExpunge = i; cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); return; } 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);}三、get()
public T get() { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) { // == 获取entry节点。从set的逻辑推断——必定有在Entry环上查找的逻辑 ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } return setInitialValue();}java.lang.ThreadLocal.ThreadLocalMap#getEntryprivate 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);}java.lang.ThreadLocal.ThreadLocalMap#getEntryAfterMissprivate 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;}