ThreadLocal的源码分析

（1）ThreadLocal是什么

ThreadLocal是一个线程本地变量，线程之间的读写是隔离的、互相不会影响。因为ThreadLocal是通过每个线程独立的保存一份副本来实现的。

（2）ThreadLocal数据结构

每一个Thread对象都含有一个ThreadLocalMap类型的成员变量threadLocals，它存储本线程中所有ThreadLocal对象及其对应的值。

ThreadLocalMap由一个个Entry对象构成，Entry继承自WeakReference<ThreadLocal<?>>，Entry的key是ThreadLocal类型，value是Object类型。

（3）源码解析

ThreadLocal类中，实现了一个静态内部类ThreadLocalMap，封装了getMap()、set()、get()、remove()等4个核心方法。

1. ThreadLocal中的静态内部类ThreadLocalMap

static class ThreadLocalMap {

        
    // Entry继承自WeakReference<ThreadLocal<?>>
    // Entry的key是ThreadLocal类型，value是Object类型
    // key采用的是弱引用，如果ThreadLocal不存在外部的强引用时，key就会被GC回收
    static class Entry extends WeakReference<ThreadLocal<?>> {
        Object value;

        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }

    // ThreadLocalMap的初始化容量为16  
    private static final int INITIAL_CAPACITY = 16;

    // ThreadLocalMap中用数组存储Entry    
    private Entry[] table;

    // table中元素的个数   
    private int size = 0;

    // 达到threshold（capacity * 2 / 3）就resize
    private int threshold;
}

2. getMap方法

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

前面有说过，每个Thread中会维护一个ThreadLocalMap，getMap方法就是获取到当前线程的ThreadLocalMap对象。

3. set方法

public void set(T value) {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 获取当前线程的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    // 如果ThreadLocalMap存在，则进行存元素；不存在先创建ThreadLocalMap
    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;
    // 先计算出key的hash，再与table的长度-1进行与运算，结果就是元素在数组中的位置
    int i = key.threadLocalHashCode & (len-1);
    
    // table数组中获取i位置的元素，如果为null，则结束循环
    for (Entry e = tab[i];
        e != null;
        e = tab[i = nextIndex(i, len)]) {
            // 判断两个key是否相同，相同则用新值替换旧值
            if (e.refersTo(key)) {
                e.value = value;
                    return;
            }

            // 判断从i位置获取到的元素的key是否为null，如果为null，说明已经被回收了，直接
            // 把新的元素存进去
            if (e.refersTo(null)) {
                replaceStaleEntry(key, value, i);
                return;
            }
    }
    
    // 在i位置获取的元素为null时，创建一个新元素存储在i位置上
    tab[i] = new Entry(key, value);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        // 判断是否需要扩容
        rehash();
}

在该方法中，先计算 hash 算出元素要存在 entry 数组的下标

如果该下标不存在元素，则直接将元素存入即可；
如果该下标存在元素，并且下标元素的 key 和新元素的 key 相同，则覆盖之前的 value；
如果该下标存在元素，并且下标元素的 key 为 null，说明entry 的 key 被GC回收了。则用新的元素替换旧的元素；
如果该下标存在元素，并且下标元素的 key 和新元素的 key 不一样且不为 null，那么从当前下标继续向后寻找可以存在该元素的地方；
如果是新增元素，则调用 cleanSomeSlots() 返回 false（没有清理到数据），并且 size 大于等于 threshold，那么会执行 rehash()，来判断是否需要扩容。

4. get方法

public T get() {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 获取当前线程中的ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        // 从map中获取Entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            // 从Entry中获取value
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

getEntry()源码

private Entry getEntry(ThreadLocal<?> key) {
    // 计算出在Entry数组中的索引
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    // 如果获取的e不为null，且key相同
    if (e != null && e.refersTo(key))
        // 返回e
        return e;
    else
        // 继续往i后面元素查找
        return getEntryAfterMiss(key, i, e);
}

getEntryAfterMiss()源码

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

    while (e != null) {
         // 如果key值相同则返回e
         if (e.refersTo(key))
             return e;
         // 如果查到的e的key等于null，表明这个entry为过期数据，那就进行一次探测式清理
         if (e.refersTo(null))
             expungeStaleEntry(i);
         else
             // 继续往数组后面查找
             i = nextIndex(i, len);
             e = tab[i];
    }
    // 没找到元素则返回null
    return null;
}

4. remove方法

public void remove() {
    // 获取当前线程中的ThreadLocalMap对象
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null) {
        // 调用ThreadLocalMap的remove方法
        m.remove(this);
    }
}

ThreadLocalMap的remove()

private void remove(ThreadLocal<?> key) {
    Entry[] tab = table;
    int len = tab.length;
    // 计算出在Entry数组中的索引
    int i = key.threadLocalHashCode & (len-1);
    for (Entry e = tab[i];
        e != null;
        e = tab[i = nextIndex(i, len)]) {
        // 判断key是否相同
        if (e.refersTo(key)) {
            // 将entry的key置为null
            e.clear();
            // 进行一次探测式清理
            expungeStaleEntry(i);
            return;
        }
    }
}

先计算出 key在数组中的索引位置i

从i开始遍历数组，遇到null停止遍历；
如果查找到key，那就会执行 clear() 把命中的 entry 的 key 设置为 null。然后执行 expungeStaleEntry()，会清理掉 entry。

（4）ThreadLocal常见问题

为什么ThreadLocal会产生内存溢出？

ThreadLocalMap使用的弱引用作为key，如果ThreadLocal不存在外部的强引用时，key就会被GC回收，导致ThreadLocalMap中key为null，而value还存在强引用，只有线程退出后，value的强引用链才会断掉。

如何避免ThreadLocal内存溢出？

ThreadLocal的正确使用方式：

1. 每次使用完TreadLocal都调用它的remove()清除数据；

2. 将ThreadLocal变量定义为private static，这样就一直存在ThreadLocal的强引用，能保证任何时候通过ThreadLocal的弱引用访问到Entry的value，进而清除。