ThreadLocal源码解析

一段代码，我们来挨着分析分析

 public static void main(String[] args) throws InterruptedException {
        ThreadLocal<String> threadLocal = new ThreadLocal<>();
        threadLocal.set("Hello World");
        threadLocal.get();
        threadLocal.remove();
    }

首先嘛，看看构造方法

public ThreadLocal() {
}

ok,就一个无参构造，没啥看的

set()

先说一下大概的原理：

• 首先获取当前线程的ThreadLocalMap实例，每一个线程都有自己的ThreadLocalMap实例
  • ThreadLocalMap中有个Entry[]数组，每个Entry对象有两个成员变量
    • private T referent：弱引用，继承自WeakReference，用来保存Threadlocal实例
    • Object value：用来保存真正的变量
• 然后判断map是否为空
  • 不为空，就赋值。以当前ThreadLocal实例作为key，值作为value
  • 为空，就新建一个ThreadLocalMap，并存储值。

注意哦：
添加数据时，ThreadLocalMap 使用线性探测法来解决哈希冲突

• 该方法会一直探测下一个地址，直到有空的地址后插入，若插入后 Map 数量超过阈值，数组会扩容为原来的 2 倍假设当前 table 长度为16，计算出来 key 的 hash 值为 14，如果 table[14] 上已经有值，并且其 key 与当前 key 不一致，那么就发生了 hash 冲突，这个时候将 14 加 1 得到 15，取 table[15] 进行判断，如果还是冲突会回到 0，取 table[0]，以此类推，直到可以插入，可以把 Entry[] table 看成一个环形数组
• 线性探测法会出现堆积问题，可以采取平方探测法解决
• 在探测过程中 ThreadLocal 会复用 key 为 null 的脏 Entry 对象，并进行垃圾清理，防止出现内存泄漏

ThreadLocal.ThreadLocalMap的部分源码：ThreadLocalMap 是 ThreadLocal 的内部类，没有实现 Map 接口，用独立的方式实现了 Map 的功能，其内部 Entry 也是独立实现

public void set(T value) {
    // 获取当前线程对象。
    Thread t = Thread.currentThread();
    
    // 使用 getMap(t) 方法获取当前线程对象绑定的 ThreadLocalMap 实例，
	//每个线程都有一个ThreadLocalMap 成员变量，看下面的Thread源码
    ThreadLocalMap map = getMap(t);
    
    // 如果当前线程对象已经有 ThreadLocalMap 实例，则直接将 ThreadLocal 对象和值存储在实例中
    if (map != null) {
        //将当前ThreadLocal实例作为key，看下面的源码
        map.set(this, value);
    } 
    // 如果当前线程对象还没有 ThreadLocalMap 实例，则创建一个新的 ThreadLocalMap 实例，并存储 ThreadLocal 对象和值
    else {
        createMap(t, value);
    }
}	
/**
内部类：散列表，用来存储数据的
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
        //实际想要存储的值
        Object value;
    	//构造方法
        Entry(ThreadLocal<?> k, Object v) {
            //继承了 WeakReference>
            //使用弱引用指向ThreadLocal实例，也就是Key值
            //相当于这个Renference类中private T referent属性保存了key的引用;   
            super(k);
            value = v;
        }
}
//实例变量
private Entry[] table;

private void set(ThreadLocal<?> key, Object value) {
    // 获取散列表
    ThreadLocal.ThreadLocalMap.Entry[] tab = table;
    int len = tab.length;
    // 哈希寻址
    int i = key.threadLocalHashCode & (len-1);
    // 使用线性探测法向后查找元素，碰到 entry 为空时停止探测
    for (ThreadLocal.ThreadLocalMap.Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
        // 获取当前元素 key
        ThreadLocal<?> k = e.get();
        // ThreadLocal 对应的 key 存在，【直接覆盖之前的值】
        if (k == key) {
            e.value = value;
            return;
        }
        // 【这两个条件谁先成立不一定，所以 replaceStaleEntry 中还需要判断 k == key 的情况】
        
        // key 为 null，但是值不为 null，说明之前的 ThreadLocal 对象已经被回收了，当前是【过期数据】
        if (k == null) {
            // 【碰到一个过期的 slot，当前数据复用该槽位，替换过期数据】
            // 这个方法还进行了垃圾清理动作，防止内存泄漏
            replaceStaleEntry(key, value, i);
            return;
        }
    }
	// 逻辑到这说明碰到 slot == null 的位置，则在空元素的位置创建一个新的 Entry
    tab[i] = new Entry(key, value);
    // 数量 + 1
    int sz = ++size;
    
    // 【做一次启发式清理】，如果没有清除任何 entry 并且【当前使用量达到了负载因子所定义，那么进行 rehash
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        // 扩容
        rehash();
}

Thread类的部分源码

public class Thread implements Runnable {
    //ThreadLocalMap实例
    ThreadLocal.ThreadLocalMap threadLocals = null;

	//获取线程的ThreadLocalMap实例
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
    
}

get()

先大概说一下原理：

• 首先获取当前线程的ThreadLocalMap实例，判断其是否为空
  • 不为空，将当前ThreadLocal实例作为key，寻找Entry[]中对应的槽位。找到了返回value，没找到进行初始化。返回默认值value。
  • 为空，初始化一个ThreadLocalMap，并将Entry的value设为默认值，返回。

public T get() {  // 获取线程局部变量的值

    Thread t = Thread.currentThread();  // 获取当前线程
    ThreadLocalMap map = getMap(t);  // 获取当前线程的 ThreadLocalMap

    if (map != null) {  // 如果 ThreadLocalMap 不为空

        ThreadLocalMap.Entry e = map.getEntry(this);  // 获取 ThreadLocal 对应的 Entry

        if (e != null) {  // 如果 Entry 不为空

            @SuppressWarnings("unchecked")
            T result = (T)e.value;  // 获取 Entry 的值，并进行类型转换
            return result;  // 返回获取到的值
        }
    }
	/*有两种情况有执行当前代码
      第一种情况: map 不存在，表示此线程没有维护的 ThreadLocalMap 对象
      第二种情况: map 存在, 但是【没有与当前 ThreadLocal 关联的 entry】，就会设置为默认值 */
    return setInitialValue();  // 如果不存在对应的 Entry，则初始化并返回初始值，后面有源码
}

private Entry getEntry(ThreadLocal<?> key) {
    // 哈希寻址
    int i = key.threadLocalHashCode & (table.length - 1);
    // 访问散列表中指定指定位置的 slot 
    Entry e = table[i];
    // 条件成立，说明 slot 有值并且 key 就是要寻找的 key，直接返回
    if (e != null && e.get() == key)
        return e;
    else
        // 进行线性探测
        /*可能发生了hash冲突导致不是存储到这个slot，因为Entry[]只是个数组，
        不像hashmap一样可以挂在链表后面，所以发生hash冲突后该值可能存储到其他slot了
        需要全部遍历一下
        */
        return getEntryAfterMiss(key, i, e);
}
/ /线性探测寻址
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    // 获取散列表
    Entry[] tab = table;
    int len = tab.length;

    // 开始遍历，碰到 slot == null 的情况，搜索结束
    while (e != null) {
		// 获取当前 slot 中 entry 对象的 key
        ThreadLocal<?> k = e.get();
        // 条件成立说明找到了，直接返回
        if (k == key)
            return e;
        if (k == null)
             // 过期数据，【探测式过期数据回收】
            expungeStaleEntry(i);
        else
            // 更新 index 继续向后走
            i = next	Index(i, len);
        // 获取下一个槽位中的 entry
        e = tab[i];
    }
    // 说明当前区段没有找到相应数据
    // 【因为存放数据是线性的向后寻找槽位，都是紧挨着的，不可能越过一个 空槽位 在后面放】，可以减少遍历的次数
    return null;
}

//初始化
private T setInitialValue() {
    // 调用initialValue获取初始化的值，此方法可以被子类重写, 如果不重写默认返回 null
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    // 判断 map 是否初始化过
    if (map != null)
        // 存在则调用 map.set 设置此实体 entry，value 是默认的值
        map.set(this, value);
    else
        // 调用 createMap 进行 ThreadLocalMap 对象的初始化中
        createMap(t, value);
    // 返回线程与当前 threadLocal 关联的局部变量
    return value;
}

remove()

原理：

1. 首先，根据要移除的 ThreadLocal 对象，计算出其在散列表中的槽位索引值。
2. 获取到该索引位置上的第一个键值对 (Entry)，并将其赋值给变量 e。
3. 进行线性探测，通过循环遍历下一个槽位，直到找到匹配的键值对或者遍历完整个散列表。
4. 在遍历的过程中，如果找到了匹配的键值对，即 e 对应的 ThreadLocal 对象与要移除的对象相同，执行以下操作：
   • 移除当前匹配的键值对 e，将其从散列表中拆除，进行探测式清理。
   • 将 e 的值设置为 null，以减少对对象的引用，方便垃圾回收。
5. 如果遍历完整个散列表仍未找到匹配的键值对，说明该键值对不存在于散列表中，无需进行移除操作。

public void remove() {
    // 获取当前线程对象中维护的 ThreadLocalMap 对象
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        // map 存在则调用 map.remove，this时当前ThreadLocal，以this为key删除对应的实体
        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)]) {
        // 找到了对应的 key
        if (e.get() == key) {
            // 设置 key 为 null
            e.clear();
            // 探测式清理
            expungeStaleEntry(i);
            return;
        }
    }
}

探测式清理：沿着开始位置向后探测清理过期数据，沿途中碰到未过期数据则将此数据 rehash 在 table 数组中的定位，重定位后的元素理论上更接近 i = entry.key & (table.length - 1)，让数据的排列更紧凑，会优化整个散列表查询性能

// table[staleSlot] 是一个过期数据，以这个位置开始继续向后查找过期数据
private int expungeStaleEntry(int staleSlot) {
    // 获取散列表和数组长度
    Entry[] tab = table;
    int len = tab.length;

    // help gc，先把当前过期的 entry 置空，在取消对 entry 的引用
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    // 数量-1
    size--;

    Entry e;
    int i;
    // 从 staleSlot 开始向后遍历，直到碰到 slot == null 结束，【区间内清理过期数据】
    for (i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        // 当前 entry 是过期数据
        if (k == null) {
            // help gc
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            // 当前 entry 不是过期数据的逻辑，【rehash】
            // 重新计算当前 entry 对应的 index
            int h = k.threadLocalHashCode & (len - 1);
            // 条件成立说明当前 entry 存储时发生过 hash 冲突，向后偏移过了
            if (h != i) {
                // 当前位置置空
                tab[i] = null;
                // 以正确位置 h 开始，向后查找第一个可以存放 entry 的位置
                while (tab[h] != null)
                    h = nextIndex(h, len);
                // 将当前元素放入到【距离正确位置更近的位置，有可能就是正确位置】
                tab[h] = e;
            }
        }
    }
    // 返回 slot = null 的槽位索引，图例是 7，这个索引代表【索引前面的区间已经清理完成垃圾了】
    return i;
}

• 
• 启发式清理：向后循环扫描过期数据，发现过期数据调用探测式清理方法，如果连续几次的循环都没有发现过期数据，就停止扫描

//  i 表示启发式清理工作开始位置，一般是空 slot，n 一般传递的是 table.length 
private boolean cleanSomeSlots(int i, int n) {
    // 表示启发式清理工作是否清除了过期数据
    boolean removed = false;
    // 获取当前 map 的散列表引用
    Entry[] tab = table;
    int len = tab.length;
    do {
        // 获取下一个索引，因为探测式返回的 slot 为 null
        i = nextIndex(i, len);
        Entry e = tab[i];
        // 条件成立说明是过期的数据，key 被 gc 了
        if (e != null && e.get() == null) {
            // 【发现过期数据重置 n 为数组的长度】
            n = len;
            // 表示清理过过期数据
            removed = true;
            // 以当前过期的 slot 为开始节点 做一次探测式清理工作
            i = expungeStaleEntry(i);
        }
        // 假设 table 长度为 16
        // 16 >>> 1 ==> 8，8 >>> 1 ==> 4，4 >>> 1 ==> 2，2 >>> 1 ==> 1，1 >>> 1 ==> 0
        // 连续经过这么多次循环【没有扫描到过期数据】，就停止循环，扫描到空 slot 不算，因为不是过期数据
    } while ((n >>>= 1) != 0);

    // 返回清除标记
    return removed;
}