ThreadLocal内存泄漏源码分析

ThreadLocal原理分析

今天我们来聊聊 ThreadLocal （后续简称 TL）这个类。以及大家常说的 ThreadLocal 所引发的内存泄漏问题！！！

什么是ThreadLocal？相信大家都知道，线程本地变量。每个线程都有独立的TL，线程私有变量，多线程安全。

如上图所示，每个线程都有自己的线程栈，TL就是在各自的线程栈开辟一块空间，这块空间就是TLM。TLM中存放的是一系列的Entry对象，entry中 key 是弱引用的TL，value是我们需要保存的值（强引用），通过上图的是示例代码发现，当TL被回收后发现value的值还存在，此时如果该线程一直处于执行中，那么value的值就属于内存泄漏（该value值永远存在无法被GC）。但是如果线程执行完成，线程栈销毁，value将被清除。所以所谓的TL内存泄漏就是因为你的线程一直处于运行状态，而TL被GC了导致value无法被使用也无法被GC。所以我们在使用TL时尝尝需要手动调用其remove()方法。通过源码我们发现当我们调用set、get方法时，都会帮助清理哪些TL被GC了的失效entry(及清理value)。下面我来分析其具体源码，看看其是如何清理的。

set方法分析

1、从当前线程中取出 ThreadLocalMap 对象

2、未初始化，对其进行初始化

3、调用其set方法存入值，key为当前 ThreadLocal ,value为用户需要保存的值

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;
    // 取出数组下标，
    int i = key.threadLocalHashCode & (len-1);
    // 从当前下标处开始遍历，直到找到第一个空的槽位停止遍历，遍历过程中发现失效的槽，调用 replaceStaleEntry
    // 清除该槽位，
    for (Entry e = tab[i]; // 取出当前下标处的entry对象值
         e != null; 
         e = tab[i = nextIndex(i, len)]) { // 循环遍历取出下一个的entry值（数组小标 + 1）
        ThreadLocal<?> k = e.get();// 取出当前entry的key值(也即TL对象)
        if (k == key) {// 如果是同一个TL，替换value值
            e.value = value;
            return;
        }
        if (k == null) { // 如果TL已经被GC，那么清理失效的 value 值
            replaceStaleEntry(key, value, i);
            return;
        }
    }
	// 当前下标处为空，直接将其存入该下标处
    tab[i] = new Entry(key, value);
    int sz = ++size;
    // 清理
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

replaceStaleEntry方法分析

从当前 staleSlot 开始遍历找到下一个需要清理的 index

private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;
    int slotToExpunge = staleSlot; // 记录需要清理的下标值
    // 改for循环的作用是从当前下标处向前遍历找到一个需要清理的槽，直到找到一个空槽结束循环
    for (int i = prevIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null) slotToExpunge = i;
 	// 向后遍历
    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        // 如果是当前TL，将 i 和 staleSlot 下标处的entry进行交换（将后后面的entry向前移动，清空后面的槽位）
        if (k == key) { 
            e.value = value;
            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;
            if (slotToExpunge == staleSlot) slotToExpunge = i; // 待清除项
            // 清除操作
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }
    tab[staleSlot].value = null;// 将原来的value引用置空
    tab[staleSlot] = new Entry(key, value);// 写入新值
    if (slotToExpunge != staleSlot)
        // 清除操作
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

expungeStaleEntry方法分析

清除失效的槽，并重新排列一下有效entry

private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    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();
        if (k == null) {// 遍历数组找到TL==null 的项全部清除
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            // 从新计算下标值
            int h = k.threadLocalHashCode & (len - 1);
            if (h != i) {
                tab[i] = null;
                // 找到新位置保存原下标 i 处的值 ，
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i; // 返回向后遍历找到的第一个空槽的 下标值
}

cleanSomeSlots方法分析

从下标 i 处遍历找到失效的槽，调用 expungeStaleEntry 执行清除操作

private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    do {
        i = nextIndex(i, len);
        Entry e = tab[i];
        if (e != null && e.get() == null) {
            n = len;
            removed = true;
            i = expungeStaleEntry(i);
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

get方法分析

调用get()方法最终会调用 TLM 的 getEntry(TL)方法，源码如下：

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
        // 未匹配到当前值时调用该方法遍历table查找
        return getEntryAfterMiss(key, i, e);
}

getEntryAfterMiss方法分析

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length; // 取出当前table的 length 长度
	// 从当前 i 索引处循环遍历列表查找，找到对应项返回，如果找到失效项将其移除（expungeStaleEntry），
    // 遍历完未找到TL对应的Entry时，返回 null 
    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        if (k == null)
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

remove方法分析

通过当前TL算出其对应的索引下标 i 的值，从当前下标向后遍历知道数组项为空停止，找到当前项清除即可，调用expungeStaleEntry方法清除其他失效的数组项

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) {
            e.clear(); // 将value引用置空
            expungeStaleEntry(i);
            return;
        }
    }
}

总结：

当主动调用set、get、remove方法时会自动清理已被GC回收了的弱引用 TL ，此时是不会发生内存泄漏的。当线程没有退出但是TL被GC了，这时就需要手动调用 remove 方法，不然就会发生内存泄漏。