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 {
    //计算出来的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> {
            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 {
       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 {
  //通过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 {
  private T referent;//这个就是ThreadLocal对象
    public void clear() {
        this.referent = null;
    }  
}