简单扣一下ThreadLocal源码

简介

ThreadLocal内部定义了一个静态内部类ThreadLocalMap，这个Map的key就是当前的ThreadLocal，value则是要存储的线程局部变量。准确的说key保存的是ThreadLocal的弱引用。在每个线程内部会维护这样的ThreadLocal.ThreadLocalMap，这样做的好处不言而喻，可以做到线程之间隔离，并且随着线程关闭，ThreadLocalMap以及其中的对象值会被回收。

插入数据

获取当前线程的ThreadLocalMap，如果已初始化就直接插入，如果未初始化就先初始化再插入。

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

我们先来分析ThreadLocalMap的set方法

private void set(ThreadLocal<?> key, Object value) {

            Entry[] tab = table;
            int len = tab.length;
            // 根据Hash值计算数据该插入的位置
            // 这个Hash值得获取是通过一个魔数递增的方式得到
            int i = key.threadLocalHashCode & (len-1);
            // 遍历桶，直到遇到桶中空槽位置停止
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();
                //key相同做覆盖操作
                if (k == key) {
                    e.value = value;
                    return;
                }
                // key为null,说明已经失效，作为弱引用，已被GC
                // 此时需要清理过期Key对应的value
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            //走到这里，说明遇到了一个空的槽，则直接插入
            tab[i] = new Entry(key, value);
            int sz = ++size;
            //先清理过期的槽，并判断是否要扩容
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                // 进行扩容，2倍，扩容前也会清理过期的槽
                rehash();
        }

可以看出在一个简单的set方法中有多次涉及到清理过期的槽，虽然清理的方法有多个，但是最终都是调用expungeStaleEntry方法。入参就是某个过期槽在桶中的位置。

 private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;
            // 当前过期的槽置为null，方便GC
            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();
                //这里将过期的槽置为null
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    //注意：走到这个分支，当前的槽未失效，前面过期槽的位置已经被腾出
                    //获取槽i处结点原本应存放的位置
                    //因为ThreadLocal解决Hash冲突的方式，h必定小于等于i
                    int h = k.threadLocalHashCode & (len - 1);
                    //h!=i，说明i处存放的结点不是它原本位置，需要挪动
                    if (h != i) {
                        //将该处的结点挪走，置为null
                        tab[i] = null;
                        // 从它原本应存放的位置h，开始遍历，
                        // 找到一个最靠近h位置的空槽，并插入数据
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            // 返回的桶中空槽的位置
            return i;
        }

通过上面源码分析，expungeStaleEntry方法做了两件事：

• 遍历桶，清理过期的key对应的value和槽（遇到空槽停止）
• 遇到未失效的槽，尝试将该槽的结点往靠近它原本位置的附近挪动
  对于第二点，我们需要补充一下，ThreadLocal解决Hash冲突的方式：
  在往ThreadLocalMap中set值时，如果当前位置已经被占，且key不相同，那它就往后找一个空的槽存放，也就是说，Map桶中元素的位置可能不是该元素本身应当存放的位置，而是靠后，所以清理过期槽后，尽量把它挪到靠近原本位置附近，这个是为了查询方便

获取值

其实分析完了set方法，我们大致也能猜出查询方法是怎么回事，无非就是根据key计数出桶的位置，如果该位置的key与当前的key不是同一个，那就往后遍历，找到key值相同的结点，遍历过程中顺带手清理一下过期的槽。

  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;
            }
        }
        //往map中存一个null的Value，并返回
        return setInitialValue();
    }

简单看下map中的get方法

       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);
        }