ThreadLocal源码分析_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 引用之外是否还有其他的的引用