ThreadLocal源码
Thread和ThreadLocal的关系
初始化ThreadLocalMap和弱引用Entry
set方法与哈希冲突
清理槽
get方法也会清理槽
扩容
手动清理的重要性
Thread和ThreadLocal的关系
每个Thread中都持有一个ThreadLocalMap的实例，ThreadLocalMap是ThreadLocal的内部类。当Thread中没有ThreadLocalMap则需要先实例化ThreadLocalMap.
public class Thread implements Runnable { ThreadLocal.ThreadLocalMap threadLocals = null;//该对象是ThreadLocal中的内部类ThreadLocalMap } public class ThreadLocal<T> { //计算出来的hash值用它来确定Entry存放到哪个哈希槽 private final int threadLocalHashCode = nextHashCode(); //这是个固定值 private static final int HASH_INCREMENT = 0x61c88647; //这个默认值是0，但new ThreadLocal后断点看到的值不是0，这是因为这是一个静态成员，在我们自己创建ThreadLocal前，main方法会先加载ThreadLocal给这个赋值了。 private static AtomicInteger nextHashCode = new AtomicInteger(); //每次调用该方法都会在原有的nextHashCode值上加上0x61c88647 private static int nextHashCode() { return nextHashCode.getAndAdd(HASH_INCREMENT); } //设置值 public void set(T value) { Thread t = Thread.currentThread();//获取当前线程。 ThreadLocalMap map = getMap(t);//获取当前线程的成员变量ThreadLocal.ThreadLocalMap threadLocals if (map != null) map.set(this, value);//如果当前线程中的ThreadLocalMap已经实例化则set else createMap(t, value);//如果当前线程中的ThreadLocalMap没有实例化则实例化。 } //在这走实例化ThreadLocalMap void createMap(Thread t, T firstValue) { t.threadLocals = new ThreadLocalMap(this, firstValue); } }
初始化ThreadLocalMap和弱引用Entry
ThreadLocalMap里最重要的属性是Entry[]，这个数组的初始长度是16，扩容阈值是size*2/3,Entry是ThreadLocalMap的内部类，Entry继承了弱引用。Entry里的key是ThreadLocal,value是设置的值。如果ThreadLocal栈引用结束了，在发生GC时虽然Entry还持有ThreadLocal的引用，这个ThreadLocal也会被垃圾回收，所以ThreadLocalMap常常伴随着扩容，清理操作。
static class ThreadLocalMap { //继承WeakReference很重要，WeakReferences是弱引用，在每次GC后都会回收弱引用对象里的引用值（若通过可达性分析查到引用值没有其他可达的Root,则会回收） //这个Entry就构成了唯一的key，也就是ThreadLocal。value是ThreadLocal.set(parameter)的参数 static class Entry extends WeakReference<ThreadLocal<?>> { Object value; Entry(ThreadLocal<?> k, Object v) { super(k);//最终传递给了Reference中的referent value = v; } } //ThreadLocalMap中的容器，一个线程持有一个ThreadLocalMap就相当于持有了一个Entry数组 private Entry[] table; //数组的初始容量 private static final int INITIAL_CAPACITY = 16; ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) { table = new Entry[INITIAL_CAPACITY];//实例化数组 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);//确定数组的位置 //初始化ThreadLocalMap不会出现hash冲突。 table[i] = new Entry(firstKey, firstValue); //已有元素++ size = 1; //计算扩容阈值 setThreshold(INITIAL_CAPACITY); } private void setThreshold(int len) { //初始化的容量第一次扩容的阈值是10，也就是说在数组的size是10的情况下就会触发扩容。 threshold = len * 2 / 3; } }
}
set方法与哈希冲突
ThreadLocal的set方法是使用ThreadLocalMap的set方法。他分为四种情况。1 计算哈希后确定的槽内是null没有Entry表示没有哈希冲突，此时new一个Entry放入槽内。 2 计算哈希后确定的槽内有Entry但是槽内的Entry的key和当前的ThreadLocal相同则直接替换value。
3 计算哈希后确定的槽内有Entry但是key和当前ThreadLocal并不是同一个，则表示哈希冲突，此时顺着数组往右寻找，直到碰到有Entry但是没有key的槽，这表示这个槽内曾经有过ThreadLocal但是被GC掉了，此时这个槽是个废槽，可以替换掉Entry。 4 哈希冲突后向右
并没有找到被GC的槽，此时只能是找到距离最近的一个槽内没有Entry的，创建一个Entry存入。
static class ThreadLocalMap { //顺着当前下标往后查询。如果查询到了数组末尾则返回0号下标 private static int nextIndex(int i, int len) { return ((i + 1 < len) ? i + 1 : 0); } //顺着当前下标往前查询。如果已经是0则返回数组末尾下标 private static int prevIndex(int i, int len) { return ((i - 1 >= 0) ? i - 1 : len - 1); } private void set(ThreadLocal<?> key, Object value) { //拿到数组 Entry[] tab = table; //数组长度 int len = tab.length; //hash&length-1 效果类似hash%length int i = key.threadLocalHashCode & (len-1); //在这就要处理hash冲突了。如果hash值不冲突，那么算出来的index位置的Entry肯定是null.那么不会进入循环。 //如果进入了循环，有没有可能两个if都不满足，有可能。这表示hash值冲突了，但是不是同一个ThreadLocal，并且hash值相同的槽内的ThreadLocal没有被GC。 //那么只能是一直找到Entry是null的位置，然后跳出循环。 for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) { ThreadLocal<?> k = e.get(); //如果是第一次循环到这里进去了，表示是同一个ThreadLocal多次设置值。则直接替换值。情况2 if (k == key) { e.value = value; return; } //如果ThreadLocal为null则表示发生了GC把弱引用ThreadLocal清理了。 //需要将当前set的key和value放入这个废掉的槽内，并且看看有没有需要清理的槽。情况3 if (k == null) { replaceStaleEntry(key, value, i); return; } } //没有进入循环，或者从循环跳出了。如果没有进入循环则i就是hash&length-1的位置表示当前算出来的hash值没有冲突，也是第一次使用。情况1 //如果是循环跳出来的，则这个i就是hash&length-1.算出来的位置向后移动循环次数的位置。表示hash冲突了，并且冲突后的槽往后也都没有被GC //只能是往后顺延找别的可用槽。总之会找到一个在数组内Entry为空的位置。创建Entry放进数组。情况4 tab[i] = new Entry(key, value); //已有元素++ int sz = ++size;
//如果没有清理槽，并且当前长度已经大于等于了阈值则扩容 if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); } //走到这个方法表示通过hash&length-1的位置上的Entry中的key是null或者是哈希冲突后，往数组后查询发现有Entry中的key是null private void replaceStaleEntry(ThreadLocal<?> key, Object value,int staleSlot) { //数组 Entry[] tab = table; //数组长度 int len = tab.length; Entry e; //Entry为null的哈希槽 int slotToExpunge = staleSlot; //从Entry为null的哈希槽位置向前找，一直找到Entry为null停止 for (int i = prevIndex(staleSlot, len);(e = tab[i]) != null;i = prevIndex(i, len)){ //在向前寻找的过程中标记Entry中key为null的下标 if (e.get() == null) slotToExpunge = i; } //从Entry为null的哈希槽位置向后找，一直找到Entry为null停止 for (int i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = nextIndex(i, len)) { //循环中的Entry中的key ThreadLocal<?> k = e.get(); if (k == key) { //如果key相同则替换value e.value = value; //将Entry中ThreadLocal为null的赋值给当前槽中 tab[i] = tab[staleSlot]; //在将Entry赋值给原来ThreadLocal为null的槽中。 //这两行操作相当于把槽里的内容互换了，达到的效果是前边的槽中的Entry有key，循环中的也就是后边的没有key tab[staleSlot] = e; //如果列表向左查询没有发现Entry中key有null的。则将当前循环中的槽的位置赋值。 //因为上两步操作已经把当前槽变成了key为null的槽，所以此处记录的位置就是key是null的位置 //如果向左查询有Entry里是null值那就表示这个区间内还有更左边有key是null的 if (slotToExpunge == staleSlot){ slotToExpunge = i; } //清理槽 cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); return; } //当前循环中的槽也是被GC过的。并且向左查询没有发现Entry为null的，就记录当前槽的位置。 if (k == null && slotToExpunge == staleSlot){ slotToExpunge = i; } } //出循环只有一种情况，key为null的Entry下标往后寻找没有发现与当前ThreadLocal相同的key。 //此时需要将原来Entry的value职位null。此操作用来释放内存。 tab[staleSlot].value = null; //创建一个新的Entry其中key是当前ThreadLocal，value是set的参数。将它放到被GC的位置。 tab[staleSlot] = new Entry(key, value); //如果向左查询有Entry中key是null的slotToExpunge就是在左边确定的 //如果向左查询没有Entry中key是null的，而向右查询有Entry中key是null的slotToExpunge就是右边确定的。 //如果两边都没有的情况表示当前区间内只有staleSlot一个为Entry是null的而这种情况下直接重新覆盖了Entry。不需要清理。条件不成立。 if (slotToExpunge != staleSlot){ cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); } } }
清理槽
expungeStaleEntry方法就是将废槽清空，然后将哈希冲突的槽重新分配位置，因为哈希冲突后是从哈希位向后移动寻找Entry是null的槽放入的，此后这些冲突的槽可能有被清理的，所以重新分配位置，方法的返回值是Entry为null的位置，cleanSomeSlots方法从这个位置
继续寻找有没有废槽，如果有就清理。
static class ThreadLocalMap { //接收的参数是槽里没有Entry的槽和当前数组的长度 private boolean cleanSomeSlots(int i, int n) { boolean removed = false; Entry[] tab = table; int len = tab.length; do { //找到下一个槽的位置 i = nextIndex(i, len); //获取槽内的Entry Entry e = tab[i]; //如果槽内有Entry，并且Entry的key是null，表示这是个废槽。 if (e != null && e.get() == null) { n = len; //有废槽肯定要清理的。 removed = true; //方法返回下一个槽内没有Entry的槽下标 i = expungeStaleEntry(i); } } while ( (n >>>= 1) != 0);//这个操作相当于折半除2的操作。10，5，2，0， return removed; } //接收的参数是槽下标内有Entry，但是Entry的key被GC了。 private int expungeStaleEntry(int staleSlot) { Entry[] tab = table; int len = tab.length; //将槽清空 tab[staleSlot].value = null; tab[staleSlot] = null; //Entry[]-- size--; Entry e; int i; //循环的开始是废槽的下一个，终止条件是下一个槽有Entry for (i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = nextIndex(i, len)) { //拿到槽内的ThreadLocal ThreadLocal<?> k = e.get(); //如果槽内的key也是null则表示这也是个废槽，则也需要做清空操作。 if (k == null) { e.value = null; tab[i] = null; size--; } else { //如果槽内有的Entry有key，则通过hash值算出槽的位置。 int h = k.threadLocalHashCode & (len - 1); //如果算出的槽位置不是当前的位置则表示这个key曾经哈希冲突了，所以位置并不是哈希位。 if (h != i) { //将这个槽清空 tab[i] = null; //从计算的哈希位开始循环，找到Entry为null的槽，将刚刚清空槽里的Entry重新安置。 while (tab[h] != null){ h = nextIndex(h, len); } //这一步的操作的意义在于，如果循环中有if条件满足的，这代表当前i这个位置之前有可用的槽，那就从哈希位开始往后找，找到空槽，重新安置这个Entry。 tab[h] = e; } } } return i;//入参staleSlot是一个废槽，返回的i则是一个Entry为null的槽。 } }
get方法也会清理槽
get方法通过当前ThreadLocal获取Entry[]中对应的Entry，如果ThreadLocalMap未实例化则实例化并返回null,通过哈希位找到了就返回，哈希位上的不是当前ThreadLocal则表示哈希冲突，继续在数组后寻找，如果途中发现有废槽则清理，如果最终没有找到则返回null。
public class ThreadLocal<T> { public T get() { //获取当前线程 Thread t = Thread.currentThread(); //获取线程内的ThreadLocalMap ThreadLocalMap map = getMap(t); //如果ThreadLocalMap已经实例化 if (map != null) { //通过ThreadLocal这个key到数组中找到Entry，是有可能找不到返回null的 ThreadLocalMap.Entry e = map.getEntry(this); //如果找到了，返回Entry中的value if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } //走到这里两种情况，1 ThreadLocalMap没有实例化，则实例化 2 从Entry[]没有找到对应ThreadLocal的Entry return setInitialValue(); } //这个方法和set差不多，但是它可以返回null。 private T setInitialValue() { //如果现在使用的就是ThreadLocal则一定返回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; } //这个方法只能子类重写，意味着可以给ThreadLocal赋默认值。 protected T initialValue() { return null; } } static class ThreadLocalMap { static class ThreadLocalMap { //通过ThreadLocal找Entry private Entry getEntry(ThreadLocal<?> key) { //计算哈希位 int i = key.threadLocalHashCode & (table.length - 1); //查看哈希位上的Entry Entry e = table[i]; //如果Entry不是null或者Entry的key就是当前的ThreadLocal则找到了返回Entry if (e != null && e.get() == key){ return e; } else{ //如果从哈希位没有找到Entry或者Entry中的key不是当前ThreadLocal return getEntryAfterMiss(key, i, e); } } //接收的参数是当前ThreadLocal，计算的哈希位，和这个哈希位上的Entry private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) { Entry[] tab = table; int len = tab.length; //从哈希位上开始循环寻找 while (e != null) { ThreadLocal<?> k = e.get(); //如果找到了key相同的则返回 if (k == key){ return e; } //如果当前槽内的key是null则要被清理 if (k == null){ expungeStaleEntry(i); }else{ //如果槽内的key有值则继续寻找。直到Entry位null停止。 i = nextIndex(i, len); } //下一个位置继续找 e = tab[i]; } //如果循环结束了，表示哈希位往后寻找的key都不是当前的ThreadLocal，返回null。 return null; } }
扩容
当数组内的元素到达阈值后触发扩容，扩容操作进行前会遍历数组进行清理。如果清理后仍然达到阈值则二倍扩容，循环扩容前的数组，根据新数组的长度重新计算哈希值，如果哈希槽内没有元素则放入，如果有则线性查询可用槽放入。然后用新的数组替换老的数组。
static class ThreadLocalMap { //扩容 private void rehash() { //清理一遍槽 expungeStaleEntries(); //大于阈值扩容 if (size >= threshold - threshold / 4) resize(); } //全部清理 private void expungeStaleEntries() { Entry[] tab = table; int len = tab.length; //遍历数组清理 for (int j = 0; j < len; j++) { Entry e = tab[j]; //发现废槽就清理 if (e != null && e.get() == null){ expungeStaleEntry(j); } } } 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]; //如果Entry不是null if (e != null) { //获取key ThreadLocal<?> k = e.get(); if (k == null) { //key是null清理 e.value = null; } else { //根据哈希值算出来在新的数组中的位置。 int h = k.threadLocalHashCode & (newLen - 1); //新的位置上有Entry表示哈希冲突，则继续向后寻找。 while (newTab[h] != null){ h = nextIndex(h, newLen); } //找到一个Entry为null的位置存放Entry。 newTab[h] = e; count++; } } } //设置新的阈值 setThreshold(newLen); //新数组内元素的总个数 size = count; //替换数组 table = newTab; } }
手动清理的重要性
clear方法就是把ThreadLocal从Entry中删除，然后删除Entry。这样Entry就没有了引用会被GC。如果不使用clear，那么就算是ThreadLocal栈内存释放了，这个对象还是存在于Thread里的ThreadLocalMap里的Entry[]数组中，除非遇到GC否则永远存在。手动清理的作用就在于不用等待GC自己把Entry清理。
public class ThreadLocal<T> { //通过ThreadLocalMap的remove方法释放内存 public void remove() { ThreadLocalMap m = getMap(Thread.currentThread()); if (m != null) m.remove(this); } ThreadLocalMap getMap(Thread t) { return t.threadLocals; } } static class ThreadLocalMap { //通过当前ThreadLocal删除 private void remove(ThreadLocal<?> key) { Entry[] tab = table; int len = tab.length; //计算哈希位 int i = key.threadLocalHashCode & (len-1); //循环找匹配的key for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) { if (e.get() == key) { //调用Refereence的clear把key清空 e.clear(); //再次清理槽。 expungeStaleEntry(i); return; } } } } public abstract class Reference<T> { private T referent;//这个就是ThreadLocal对象 public void clear() { this.referent = null; } }
