ThreadLocal源码分析

1.ThreadLocal 是什么

Threadlocal 是 jdk 中一个非常重要的工作类。它是线程本地存储，可以保证各个线程之间的变量互不干扰。

它的数据结构：

ThreadLocalMap有点类似HashMap的结构，只是HashMap是由数组+链表实现的，而ThreadLocalMap中并没有链表结构。

注意Entry， 它的key是继承自WeakReference， 是弱引用类型，在 GC 时，key 有可能会被回收掉。

2.ThreadLocal 的方法

2.1 set()

点进去 set() 方法，源码如下：

public void set(T value) {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 获取当前线程的ThreadLocalMap
    ThreadLocal.ThreadLocalMap map = getMap(t);
    // 如果map存在就存储value，不存在先创建map，再设置value
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

第一步就是获取当前线程，然后拿到当前线程的 ThreadLocalMap，数据就是存在这个ThreadLocalMap 中。

createMap() 的源码很简单，作用是初始化ThreadLocalMap，并添加第一个元素，元素的key为当前ThreadLocal对象，源码如下：

void createMap(Thread t, T firstValue) {
    // 初始化ThreadLocalMap，并添加第一个元素，元素的key为当前ThreadLocal对象
    t.threadLocals = new ThreadLocal.ThreadLocalMap(this, firstValue);
}

继续看初始化ThreadLocalMap的源码：

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    // 初始化entry数组，初始大小INITIAL_CAPACITY=16
    table = new Entry[INITIAL_CAPACITY];
    // 计算ThreadLocal对象的hash，用作下标
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    // 把第一个元素的放在计算出来的下标上
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    // 设置Threshold为初始大小，Threshold是用来扩容的
    setThreshold(INITIAL_CAPACITY);
}

以上是 ThreadLocalMap 为 null 的逻辑。重点逻辑在 ThreadLocalMap 不为空时，执行的 set() 方法。源码如下：

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

    Entry[] tab = table;
    int len = tab.length;
    // 计算hash，作为数组下标
    int i = key.threadLocalHashCode & (len-1);

    // 从下标i开始遍历entry数组，直到元素为null停止遍历
    // nextIndex就是把i++，如果i等于数组长度，那么i重新设置0
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        // 获取key，key是弱引用，可能是null
        ThreadLocal<?> k = e.get();
        // 如果k等于key（==是判断内存地址），那么把value更新一下
        if (k == key) {
            e.value = value;
            return;
        }
        // 如果key是null，那么替换过期的key
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    // 如果for循环没有进去，也就是数组下标i的元素是null，
    // 那么该下标填充一个新的entry
    tab[i] = new Entry(key, value);
    int sz = ++size;
    // 如果没有清理数据，并且数组长度大于等于threshold
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        // 判断是否需要扩容
        rehash();
}

在该方法中，先计算 hash 作为 entry 数组下标，此时：

• 如果该下标不存在元素，那么直接设置值。
• 如果该下标存在元素，并且下标元素的 key 和传递的 key 一样，那么覆盖之前的 value。
• 如果该下标存在元素，并且下标元素的 key 为 null，那么这个 entry 是一个过期的 entry，因为 entry 的 key 被GC回收了。这时会替换这个位置的 entry。
• 如果该下标存在元素，并且下标元素的 key 和传递的 key 不一样也不为 null，那么从当前下标继续向后寻找可以存在该元素的地方。

在最后，如果 cleanSomeSlots() 返回 false（没有清理到数据），并且 size 大于等于 threshold，那么会执行 rehash()，来判断是否需要扩容。

replaceStaleEntry()，这个方法会替换过期数据的逻辑，源码：

private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                               int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    // 开始扫描的起点，初始值和过期元素的下标相等
    int slotToExpunge = staleSlot;
    // 从传递的下标（不包含）开始向前遍历，直到元素为null停止
    for (int i = prevIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        // 目的在于确定slotToExpunge的值
        if (e.get() == null)
            slotToExpunge = i;

    // 从传递的下标（不包含）开始向后遍历，直到元素为null停止
    // 这个循环做两件事：1.确定开始清理数据的起点slotToExpunge；2.更新相同key的entry
    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        // 获取entry的key
        ThreadLocal<?> k = e.get();

        // 遇到entry的key和传递进来key相等，就覆盖entry的value
        if (k == key) {
            // 新的value替换老的value
            e.value = value;
            // 把过期元素和当前下标的元素交换位置
            // 从这里可以看出，并不是直接替换过期entry，而是从过期entry下标向后找到一个key相同的entry
            // 然后更新key相同的entry，再把更新后entry和过期entry交换位置。
            // 自我猜测一下，这么做是想确定slotToExpunge的值，以此来更好的开展清理数据的工作
            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;
            // 如果向前扫描是没有设置slotToExpunge，那么把slotToExpunge设置为i
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            // 先从slotToExpunge开始探测式清理，然后再进行启发式清理
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            // 替换过期元素结束后，结束循环
            return;
        }

        // 如果向前扫描是没有设置slotToExpunge，那么此时把遇到的第一个过期数据的下标设置为slotToExpunge
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // 如果始终找不到过期元素，那就创建新的元素放到过期下标的位置上
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    // slotToExpunge不等于staleSlot，意味着之前找到了其他过期entry，那么开始从slotToExpunge清理过期数据
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

仔细看 replaceStaleEntry() 会发现，在替换过期 entry 时候，不仅替换过期 entry，也把 entry 数组给清理了一遍。

清理过期 entry 的方法是 cleanSomeSlots() 和 expungeStaleEntry()，接着看下两个方法的源码：

cleanSomeSlots()：

private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    // 循环清理过期数据，启发式清理
    do {
        // 获取i后面的一个下标
        i = nextIndex(i, len);
        Entry e = tab[i];
        // 如果元素不等于null并且key已经被GC回收
        if (e != null && e.get() == null) {
            n = len;
            removed = true;
            // 把过期数据清理掉，探测式清理，从当前脏entry会再往后寻找脏entry进行清理，碰到null时结束。
            i = expungeStaleEntry(i);
        }
    }
    // n >>>= 1 说明要循环log2(n)次。
    // 这个官方说不调用n次来清除，为了效率，而且经过测试调用log(n)次清除无效的数据的效果已经很好了。
    while ( (n >>>= 1) != 0);
    return removed;
}

官方释义：启发式清理。内部逻辑是一个 while 循环，循环次数是 log2(n) 次，方法的返回值含义为是否清理过。

expungeStaleEntry()：

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

    // 清理过期的key
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

    // 开始清理其他过期的key，探测式清理
    Entry e;
    int i;
    // 从入参staleSlot往后开始遍历清理，直到元素为null停止
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        // 获取弱引用key
        ThreadLocal<?> k = e.get();
        // key为null那么把这个下标元素设置为null
        if (k == null) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            // key不为null
            // 重新计算hash
            int h = k.threadLocalHashCode & (len - 1);
            // 如果新的hash不等于目前的下标（产生了hash冲突），那么就把当前下标元素设置为null
            if (h != i) {
                tab[i] = null;

                // 从h开始向后找一个为null的下标元素
                while (tab[h] != null)
                    h = nextIndex(h, len);
                // 找到了。把e设置到这个新的位置上。注意：这里的下标和key计算的hash可能并不相等
                tab[h] = e;
            }
        }
    }
    return i;
}

官方释义：探测式清理。它会把入参作为起点一直向后遍历清理过期数据，遇到null元素停止，然后把null元素的下标返回。

再次回到前面的 set()，当把过期 entry 替换后，会再次执行一次 cleanSomeSlots() 方法来清理数据，如果 cleanSomeSlots() 返回 false，那就表明没有清理到任何过期 entry。这时会判断 size 是否已经大于等于 threshold。如果上述的条件成立了，会执行 rehash()，看看是否需要进行扩容。

rehash()：

private void rehash() {
    // 再次清理一次entry数组
    expungeStaleEntries();

    // 此时如果size依旧大于等于 threshold*3/4，就进行扩容
    if (size >= threshold - threshold / 4)
        resize();
}

在方法中，第一步先整体再次清理一次过期 entry，如果清理后，size依旧大于等于 threshold*3/4，就会进行扩容。

expungeStaleEntries()：

private void expungeStaleEntries() {
    Entry[] tab = table;
    int len = tab.length;
    // 遍历整个entry数组
    for (int j = 0; j < len; j++) {
        Entry e = tab[j];
        // 如果entry不为null并且key被GC回收了，就从当前下标开始进行一次探测式清理
        if (e != null && e.get() == null)
            expungeStaleEntry(j);
    }
}

expungeStaleEntries() 会遍历整个 entry 数组，每遇到一个过期的 entry，就会从这个 entry 的位置进行一次探测式清理。

resize()：

private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    // 扩容为2倍
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    // 设置元素的次数，等于size
    int count = 0;
    // 从0开始循环遍历
    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        // 如果元素不等于null
        if (e != null) {
            ThreadLocal<?> k = e.get();
            // 如果key不存在，即entry过期了，把value设置为null，帮助GC回收
            if (k == null) {
                e.value = null;
            } else {
                // 计算新的hash，作为下标
                int h = k.threadLocalHashCode & (newLen - 1);
                // 如果新的下标存在元素（hash冲突），那就向后寻找一个元素为null的下标
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                // 设置元素
                newTab[h] = e;
                count++;
            }
        }
    }
    // 设置Threshold，注意这不是简单的 set 方法，内部会乘以2/3的
    setThreshold(newLen);
    size = count;
    table = newTab;
}

resize() 是扩容方法。长度扩容为之前的两倍，会把 Threshold 重新设置。

2.2 get()

get() 会从 ThreadLocal 中读取之前 set 的数据。它会以当前 ThreadLocal 为 key，去 ThreadLocalMap 中寻找数据。

get()：

public T get() {
    // 获取当前线程的ThreadLocalMap
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        // 把当前ThreadLocal作为key，获取map中的entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            // 获取entry的value，然后返回value
            T result = (T)e.value;
            return result;
        }
    }
    // map为null就返回null
    return setInitialValue();
}

第一步会获取当前线程的 ThreadLocalMap，然后把当前 ThreadLocal 作为 key 去ThreadLocalMap 中寻找数据，如果找不到就返回 null。获取数据调用的是 getEntry()。

getEntry()：

private Entry getEntry(ThreadLocal<?> key) {
    // 计算key的hash作为下标
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    // 判断这个下标的entry是否存在，存在的话key是不是和目标key一致
    if (e != null && e.get() == key)
        // 条件都符合，返回这个entry
        return e;
    else
        // 从计算出的下标开始，向后寻找目标entry
        return getEntryAfterMiss(key, i, e);
}

根据 key 计算下标，如果这个下标的 entry 存在并且 entry 的 key 也没有被 GC 回收，那就命中这个 entry 返回。否则的话，调用 getEntryAfterMiss()，循环在 entry 数组中寻找目标 entry。

getEntryAfterMiss()：

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;

    // 循环遍历，直到entry为null
    while (e != null) {
        ThreadLocal<?> k = e.get();
        // key和目标key相同，直接返回这个entry
        if (k == key)
            return e;
        // k等于null，表明这个entry为过期数据，那就进行一次探测式清理
        if (k == null)
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        // 没有找到目标entry，向后继续寻找
        e = tab[i];
    }
    // 怎么都找不到就返回null
    return null;
}

循环遍历 entry 数组，发现过期数据就探测式清理一次数据，返回目标 entry 就命中返回。

2.3 remove()

remove()，移除数据。

public void remove() {
    // 获取当前线程的ThreadLocalMap
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        // 把当前ThreadLocal对象作为key，在ThreadLocalMap中移除这个key
        m.remove(this);
}

第一步获取当前线程的 ThreadLocalMap，第二步把当前 ThreadLocal 对象作为 key，在ThreadLocalMap 中移除掉。

再看 m.remove(this) 的源码：

private void remove(ThreadLocal<?> key) {
    Entry[] tab = table;
    int len = tab.length;
    // 计算hash作为下标
    int i = key.threadLocalHashCode & (len-1);
    // 从i开始遍历数组，遇到null停止遍历
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        // 如果entry的key等于入目标key，清理entry，并进行一次探测式清理
        if (e.get() == key) {
            // 会把entry的key设置为null，这时entry就会变成过期数据
            e.clear();
            expungeStaleEntry(i);
            return;
        }
    }
}

计算出 key 的 hash 作为下标，然后从i开始遍历数组，遇到null停止遍历。在遍历时，如果命中了key，那就会执行 clear() 把命中的 entry 的 key 设置为 null。这是这个 entry 就是过期数据了，然后紧接着执行 expungeStaleEntry()，会清理掉过期的 entry。

3. 相关问题

问：ThreadLocal 中 key 为什么要使用用弱引用？value使用强引用？

答：在数据使用完毕后，继续放在 ThreadLocalMap 已经没有意义，所以程序可以主动让数据在GC是被回收掉。但是直接把 entry 设置成弱引用不合理，因为 vlaue 是用户传递进来的，value 可能在其他地方存在引用。

value 不设置为弱引用是因为不清楚除了 ThreadLocal 引用之外是否还有其他的的引用

问：ThreadLocal会有内存泄露吗？

答：存在。因为 value 是强引用，不会被GC回收，而 ThreadLocal 自动清理数据是在调用 set()、get()、remove() 是进行的，如果长时间不调用 set()，get()，remove() 方法，会有内存泄露的风向。

问：ThreadLocal为什么不用链表？

答：个人觉得，key 是会被 GC 回收的，那么这 ThreadLocalMap 中的数据存在时间并不是很稳固，可能随时被GC回收。因此没必要在使用链表来优化性能了。

问：ThreadLocal什么时候扩容？

答：在 set() 时，先判断 size 是否大于 threshold，如果是的话，清理一次 entry 数组，然后再判断一次 size 是否大于 threshold3/4。如果这时依旧成立，那么进行扩容。