ThreadLocal底层原来是这样实现的，快来跟我一起看看吧

ThreadLocal学习笔记

一、ThreadLocal是什么

• ThrealLocal是jdk1.2就有的一个类，主要是一个线程本地变量
• 同一个ThreadLocal对象在不同的线程中维护了不同的副本
• 由于每个不同线程会维护相同对象的不同副本，所以不存在变量共享的问题

二、ThreadLocal有什么用

• 可以用来做数据隔离
• 最经典的就是spring的事务隔离就是用ThreadLocal隔离了Connection

三、ThreadLocal的数据结构

• 每个Thread里都维护了一个threadLocals对象,他是ThreadLocalMap类型的
• 每次操作ThreadLocal(get、set、remove)变量时，就会去访问threadLocals对象，
• ThreadLocalMap是ThreadLocal的一个内部类，没有实现Map接口，内部是一个继承WeakReference的Entry，初始大小也是16，因为同一个线程可能有多个ThreadLocal对象，所以内部需要一个Entry数组，每个不同的ThreadLocal对象对应着不同的Entry。
• Entry的key是ThreadLocal本身，是一个弱引用，在发生GC的时候便于回收，但要是没有使用得当也会产生内存泄露的问题
• ThreadLocal有threadLocalHashCode成员变量自己维护的hashCode，定位Entry时也是通过这个变量来寻找数组的下标

大致的数据结构图就是这样

四、ThreadLocal源码解析

set方法解析

• 获取当前线程以及当前线程的threadLocals的Map对象
• map为空就new一个Map，并且初始化容量、resize阈值，并set第一个key，value等
• 当调用ThreadLocalMap的set方法发现有发生过GC的话，就会对整个entry进行一次replaceStaleEntry，更新key为null的entry，把他们的entry本身、entry的value都置为null，然后rehash

public void set(T value) {
    //当前线程
    Thread t = Thread.currentThread();
    //当前线程维护的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null)
        //调用ThreadLocalMap的set方法
        map.set(this, value);
    else
        //初始化ThreadLocalMap并存入第一个值
        createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}
//ThreadLocalMap的set方法
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;
    //通过threadLocalHashCode找到Entry数组的下标
    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;
        }
        //个人理解为被GC了，所以entry不是null，但是key为null了，因为弱引用
        //清除当前entry数组中所有的entry
        if (k == null) {
            //将废弃的entry都更新为null entry(null,null)
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    tab[i] = new Entry(key, value);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
    }

get方法解析

• 同样先获取当前线程和当前线程的ThreadLocalMap
• map不为空的话就去getEntry
• map为空的话会先初始化ThreadLocalMap，包括初始化16大小entry数组，resize阈值大小，已经第一个key，value
• 调用getEntry方法通过hashCode定位到entry数组的下标，获取到就直接返回entry，否则会把从当前位置开始到下一个key为null之前的所有entry都置为null，然后rehash

public T get() {
    //还是获取当前线程
    Thread t = Thread.currentThread();
    //以及当前线程的ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        //getEntry方法传入的this
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //初始化当前Thread的Map
    return setInitialValue();
}

private Entry getEntry(ThreadLocal<?> key) {
    //通过当前对象的hashCode定位到entry的下标
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    if (e != null && e.get() == key)
        //找到就直接返回
        return e;
    else
        //reHash当前位置直到下一个null entry之前的数据
        return 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)
            //rehash当前null数据直到下一个不为null之前的数据
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

private T setInitialValue() {
    //protected方法，可自己实现,默认是null
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        //调用构造方法初始化，包括初始化大小为16的Entry数组
        //设置第一个entry(key，value)
        //设置resize的阈值为容量的2/3
        createMap(t, value);
    return value;
}

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;
    setThreshold(INITIAL_CAPACITY);
}

expungeStaleEntry方法

• 主要的清除空entry的方法
• rehash的方法

private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    // expunge entry at staleSlot
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

    // Rehash until we encounter null
    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--;
            } else {
                int h = k.threadLocalHashCode & (len - 1);
                if (h != i) {
                    tab[i] = null;

                    // Unlike Knuth 6.4 Algorithm R, we must scan until
                    // null because multiple entries could have been stale.
                    while (tab[h] != null)
                        h = nextIndex(h, len);
                    tab[h] = e;
                }
            }
        }
        return i;
}

remove方法解析

• 都是先获取当前线程的Map
• 然后调用map的remove方法
• remove方法里先是定位到entry下标，然后循环遍历entry数组（不理解为啥定位到了下标还要循环遍历数组），分别清除key的软引用，value和entry，然后rehash

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

private void remove(ThreadLocal<?> key) {
    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)]) {
         if (e.get() == key) {
            //清除key的软引用
            e.clear();
            //清除value和entry，rehash
            expungeStaleEntry(i);
            return;
        }
    }
}

五、注意事项

• 因为ThreadLocalMap中的Entry是一个弱引用，但是Entry的value是一个强引用，使用完需要remove掉，不然会导致内存泄露
• ThreadLocalMap并没有像HashMap用链表和红黑树来解决冲突，只是通过遍历空的位置来插入新的entry，所以冲突多的话，遍历的开销是有的