ThreadLocal源码分析

ThreadLocal简介

• 从java官方文档中描述：ThreadLocal类用来提供线程内部的局部变量，这种变量再多线程环境下访问（通过get和set方法访问）时能保证各线程的变量相对独立于其他线程内的变量。
• ThreadLocal实例通常来说都是private static类型的，用于关联线程和线程上下文。
• ThreadLocal作用：
  • 提供线程内的局部变量，不同的线程之间不会相互干扰，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度
• 总结：
  • 1、线程并发：在多线程并发的场景下
  • 2、传递数据：可以通过ThreadLocal在同一个线程，不同组件（controller、service或dao）中传递公共变量
  • 3、线程隔离：每个线程的变量都是独立的，不会相互影响

ThreadLocal 基本使用

常用方法

方法声明	描述
ThreadLocal()	创建ThreadLocal对象
protected T initalValue()	返回当前线程局部变量的初始值
public void set(T value)	设置当前线程绑定的局部变量
public T get()	获取当前线程绑定的局部变量
public void remove()	移除当前线程绑定的局部变量

ThreadLocal与synchronized的区别

• 虽然ThreadLocal模式与synchronized关键字都用于处理多线程并发访问变量的问题，不过两者处理问题的角度和思路不同。

	synchronized	ThreadLocal
原理	同步机制采用“以时间换空间”的方式，只提供了一份变量，让不同的线程排队访问	ThreadLocal采用“以空间换时间”的方式，为每个线程都提供了一份变量的副本，从而实现同时访问而互不干扰
侧重点	多线程之间访问资源的同步	多线程中每个线程之间的数据相互隔离

ThreadLocal的内部结构

常见的误解

• JDK早期的设计：每个ThreadLocal内部都有一个Map，用线程作为Map的key，要存储的局部变量作为Map的value。
  

现在的设计

• 在JDK8中ThreadLocal的设计是：每个Thread维护一个ThreadLocalMap，这个Map的key是ThreadLocal实例本身，value是要存储的局部变量
  
  具体的过程是这样的：
• （1）每个Thread线程内部都有一个Map(ThreadLocalMap)
• （2）Map里面存储ThreadLocal对象（key）和线程的变量副本（value）
• （3）Thread内部的Map由ThreadLocal维护，由ThreadLocal负责向，ap获取和设置线程的变量值
• （4）对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离

好处

• 1、 每个Map存储的Entry数量变少了
  • 早期的设计中，Entry的数量由线程数来决定
  • JDK8的设计中，Entry的数量由ThreadLocal的个数来决定，也就是局部变量的个数来决定
  • 对一个线程来说，需要传递使用的局部变量个数可能就只有几个，但一个程序中的线程数那可能就很多了
• 2、当Thread销毁的时候，ThreadLocalMap也会随之销毁，减少内存的使用

ThreadLocal的核心方法源码

public void set(T 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对象
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}
//初始化ThreadLocalMap，并将当前ThreadLocal和对应的值value作为第一个entry存放至ThreadLocalMap
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

• 首先获取当前线程，并根据当前线程获取一个Map
• 如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key）
• 如果Map为空，则给该线程创建Map，并设置初始值

public T get()

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
    	// 根据key获取map中对应的Entry节点
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    /*
    初始化：
    情况1：map不存在，此线程没有维护过ThreadLocalMap
    情况2：map存在，但没有与当前线程关联的entry节点
    */
    return setInitialValue();
}

// java.lang.ThreadLocal$ThreadLocalMap.getEntry(ThreadLocal<?>)
// 根据key获取Entry节点
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
        return getEntryAfterMiss(key, i, e);
}

// 初始化
private T setInitialValue() {
	// 获取初始化的值
	// 此方法可以被子类重写，不重写默认返回null
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

• 首先获取当前线程，根据当前线程获取一个Map
• 如果获取的Map不为空，则获取Map中以ThreadLocal对象为key对应的Entry e
• 如果e不为空，则返回e.value
• 如果Map为空或者e为空，则通过initialValue获取初始值value，然后创建一个新的Map

public void remove()

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

protected T initialValue()

// 返回当前线程对应的ThreadLoacl的初始值
protected T initialValue() {
    return null;
}

• 这个方法仅仅简单的返回null，如果想要初始化线程局部变量，必须通过子类继承ThreadLocal的方式重写次方法，通常可以通过匿名内部类的方式实现

private static final ThreadLocal<byte[]> CACHED = new ThreadLocal<byte[]>() {
	@Override
	protected byte[] initialValue() {
		return new byte[1024];
	}
};

ThreadLocalMap源码分析

基本结构

• ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，用独立的方式现实了Map功能，内部的Entry也是独立实现的
  

成员变量

// 初始容量16 必须是2的整数次幂
private static final int INITIAL_CAPACITY = 16;
private Entry[] table;
private int size = 0;
// 用于扩容的阈值 threshold = capacity * 2/3;，当size > threshold,进行扩容
private int threshold;

存储结构-Entry

// java.lang.ThreadLocal$ThreadLocalMap$Entry
static class Entry extends WeakReference<ThreadLocal<?>> {
    Object value;

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

• Entry 继承 WeakReference，key（ThreadLocal）是弱引用，其目的是将ThreadLocal对象的声明周期和线程的生命周期解绑

弱引用和内存泄漏

1、内存泄漏相关概念

• Memory overflow：内存溢出，没有足够的内存提供申请者使用
• Memory leak：内存泄漏，指程序中已动态分配的堆内存由于某种原因未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。内存泄漏的堆积最终导致内存溢出

2、弱引用相关概念

• java中的引用由4种类型：强、软、弱、虚。
• 强引用(String Reference)，就是最常见的普通对象引用，只要还有强引用指向一个对象，就能证明对象还“活着”，垃圾回收器就不会回收这种对象
• 弱引用(WeakReference)，垃圾回收器一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存

3、如果key使用强引用

• 假设在业务代码中使用完ThreadLocal，ThreadLocal Ref被回收
• 由于ThreadLocalMap的Entry强引用了ThreadLocal，那么这个ThreadLocal就无法被回收
• 如果没有手动删除这个Entry，并且当前线程仍处于运行状态，那么这个Entry就不会被回收，导致ThreadLocal也不会被回收(ThreadLocal和Entry无用内存无法回收，可能导致内存泄漏)

4、如果key使用弱引用

• 假设在业务代码中使用完ThreadLocal，ThreadLocal Ref被回收
• 由于ThreadLocalMap的Entry弱引用了ThreadLocal，ThreadLocal就只具有弱引用，那么垃圾回收器进行gc时就会将ThreadLocal回收
• 假设此时一样没有手动删除这个Entry，并且当前线程仍处于运行状态，那么这个Entry就不会被回收，但ThreadLocal无用内存已经回收，不会因为ThreadLocal导致内存泄漏 （注意，也是有内存泄漏的可能，Entry其实也是无用内存，但是不会被释放，此时的内存泄漏就是Entry导致的）

ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应的keythreadLocal.remove()就会导致内存泄漏。

5、为什么使用弱引用

• 要避免内存泄漏的两种方式：
  • （1）使用完ThreadLocal，调用其remove方法删除对应的Entry
  • （2）使用完ThreadLocal，当前Thread也随之结束运行
• 事实上，在ThreadLocalMap中的set/getEntry方法中，会对key为null（也就是ThreadLocal为null，即ThreadLocal被垃圾回收了）进行判断，如果为null，那么就会将value也置为null
• 这就意味着，使用完ThreadLocal，当前线程仍然处于运行状态，就算忘记调用remove方法，弱引用比强引用可以多一层保障，弱引用的ThreadLocal会被回收，对应的value在下一次ThreadLocalMap调用set，get，remove中的任一方法的时候会被清除，从而避免内存泄漏

ThreadLocalMap hash冲突的解决

（1）从ThreadLocal的set()方法入手

• 首先获取当前线程，并根据当前线程获取一个Map
• 如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key）这里调用了ThreadLocalMap的set方法
• 如果Map为空，则给该线程创建Map，并设置初始值这里调用了ThreadLocalMap的构造方法

（2）ThreadLocalMap构造方法

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    table= new Entry[INITIAL_CAPACITY];
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    setThreshold(INITIAL_CAPACITY);
}
// firstKey.threadLocalHashCode

• （1）关于firstKey.threadLocalHashCode，来看看ThreadLocal 类的 threadLocalHashCode 成员变量是如何定义及计算的

private final int threadLocalHashCode = nextHashCode();
private static AtomicInteger nextHashCode = new AtomicInteger();
// 特殊的hash值
private static final int HASH_INCREMENT = 0x61c88647;
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

• HASH_INCREMENT：这个值和斐波那契数列（黄金分割数）有关，目的是为了能让hash值均匀分布在2的n次方的数组中，这样可以尽量避免hash冲突
• （2）计算key的下标 与操作
  i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1)

（3）ThreadLocalMap的set方法

private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
    // 计算key的索引下标
    int i = key.threadLocalHashCode & (len-1);
	// 从索引下标开始遍历，查找非空的entry
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
		// 如果找到key，直接将新的value赋值
        if (k == key) {
            e.value = value;
            return;
        }

		// 如果key为空，会开始擦除操作，并且替换Entry为当前的key和value
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
	// 数组中不存在指定key的entry，插入新的Entry
    tab[i] = new Entry(key, value);
    int sz = ++size;
    // 先进行擦除操作，如果擦除完size还是大于扩容阈值，进行扩容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

// 得到下一个索引下标，table可以当作是个环形数组，到头之后再从0开始
private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}

private void rehash() {
	// 清除所有过期（STALE状态）的Entry，即key为null的Entry
    expungeStaleEntries();
    // 清除过程中，size会减小，在此处重新计算是否需要扩容
    // 并没有直接使用threshold，而是用更低的threshold（约threshold的3/4）提前触发resize
    if (size >= threshold - threshold / 4)
        resize();
}

ThreadLocalMap使用线性探测法来解决hash冲突的
该方法一次探测下一个地址（table可以当作是个环形数组），直到有空的地址后插入，若整个空间都找不到空余的地址，则产生溢出。

执行过程:

• 1）首先根据Key值计算HashIndex，对应至Entry数组索引start_i，并从start_i开始遍历；
• 2）如果查找到对应Key的Entry，则直接替换Value值，返回；
• 3）如果查找到STALE状态Entry，则执行替换无效状态方法，并返回；
• 4）如果遇到空Entry，则直接设置Key，Value值，并判断Entry数组是否需要扩容；
• 因为此处Entry数组新增了一个Entry，所以首先执行一次启发式擦除过程，如果成功擦除了元素，表明Entry数组并无变大，不需要扩容，否则，新增一个元素后，如果Entry数组大小大于阈值，则进行扩容。

（4）ThreadLocalMap的getEntry方法

• 根据传参Key值获取对应Entry，包括直接命中获取和碰撞查找获取

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
        return getEntryAfterMiss(key, i, e);
}
// 碰撞查找
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;
	// 从第i个开始，开始遍历查找key对应Entry
    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;
}

执行过程：

• 1）查找到，直接返回对应Entry；
• 2）未找到：
  • 2.1）如果当前位置Entry为 SATLE无效状态，则执行擦除过程（擦除过程会重新计算遇到的有效Entry HashIndex，并重新设置所在Entry数组位置），并从当前位置继续开始查找判断；
  • 2.2）如果当前位置Entry为有效状态，则递进至下一位置；
• 3）如果遇到空Entry，退出循环，并返回null。

ThreadLocalMap 元素擦除机制

expungeStaleEntry(int staleSlot)

• 从指定下标(无效槽位)开始擦除无效状态Entry

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

    // 首先将这个槽位引用置空，擦除value及Entry
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--; // 擦除过程中，Entry的个数减1

    // 擦除staleSlot到下一个null之间的所有无效节点，有效节点rehash，重新放置到正确的位置
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        if (k == null) { // 擦除无效节点
            e.value = null;
            tab[i] = null;
            size--;
        } else { // 有效节点rehash
            int h = k.threadLocalHashCode & (len - 1); // 计算当前key的真实索引下标
            // h <= i
            // 情况1：h=i，有效节点的位置正确，不需要移动
            // 情况2：h<i，有效节点插入时hash冲突了，线性探测放置到后面的位置上了，此时要修正有效节点的索引（前面已经擦除了staleSlot，所以这个有效节点的位置一定会往前移动的）
            if (h != i) {
                tab[i] = null; // 擦除i的位置
                while (tab[h] != null) // 找到有效节点的正确下标
                    h = nextIndex(h, len);
                tab[h] = e; // 将有效节点放到正确的位置
            }
        }
    }
    return i;// 返回此次擦除过程结束的下标（Entry为空的节点下标）
}

执行步骤如下：

• 1）直接擦除参数指定索引位置Entry；
• 2）从下一个位置开始遍历，直到遇到空Entry返回；
  • 2.1）如遍历位置为STALE状态Entry，擦除；
  • 2.2）如遍历位置非STALE状态Entry，重新计算HashIndex，如和当前索引无冲突，则继续下个遍历；否则，重新插入，并把当前位置置空。

cleanSomeSlots(int i, int n)

• 启发式扫描擦除。从 i+1 开始扫描检查，如果连续 log₂n 个单元不需要擦除则结束方法，否则找到一个过期节点，重置计数，将n置为数组长度，重新开始新一轮的扫描。
• 只有扫描过程中有一个过期节点，则认为擦除成功，返回true。

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); // 从i开始擦除无效状态Entry
        }
    } while ( (n >>>= 1) != 0); //n=n/2 循环次数:log(n)
    return removed;
}

expungeStaleEntries()

全量扫描擦除，扫描整个Entry数组。

private void expungeStaleEntries() {
    Entry[] tab = table;
    int len = tab.length;
    for (int j = 0; j < len; j++) {
        Entry e = tab[j];
        if (e != null && e.get() == null)
            expungeStaleEntry(j);
    }
}

replaceStaleEntry方法

• 清除无效的Entry并替换为新的key和value的

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

    // slotToExpunge  表示第一个过期节点
    int slotToExpunge = staleSlot;
    // 向前查找第一个过期的节点
    for (int i = prevIndex(staleSlot, len); // 当前索引下标的前一个下标
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;

    // Find either the key or trailing null slot of run, whichever
    // occurs first
    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();

        // If we find key, then we need to swap it
        // with the stale entry to maintain hash table order.
        // The newly stale slot, or any other stale slot
        // encountered above it, can then be sent to expungeStaleEntry
        // to remove or rehash all of the other entries in run.
        if (k == key) {
            e.value = value;
			// 交换
            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

            // Start expunge at preceding stale entry if it exists
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        // If we didn't find stale entry on backward scan, the
        // first stale entry seen while scanning for key is the
        // first still present in the run.
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // 如果key没有找到
    // 擦除无效Entry的value值，创建新的Entry放到无效Entry的槽位上
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    // 启发式扫描擦除无效Entry
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

slotToExpunge表示第一个过期节点
（1）从staleSlot向前扫描，扫描到第一个为null的节点截止，如果中间有过期节点，记录扫描过程中遇到的最后一个过期节点的下标为slotToExpunge。
（2）从staleSlot向后扫描，扫描到找到key值对应的节点或null节点截止，如果在（1）的扫描中没有找到过期节点，需要本次扫描中遇到的第一个过期节点的下标记录为slotToExpunge。如果找到了key值对应的节点，覆盖后将该节点移到staleSlot处，并该节点的原来位置作为过期节点处理。如果没有找到节点，新建节点放置到staleSlot处。
（3）如果在两次扫描中找到了过期节点，先对该节点进行擦除，并调用启发式扫描擦除。

总的来说，假如i下标处的节点是staleSlot节点左边离得最近的null节点，j下标处的节点是staleSlot节点左边离得最近的null节点，并且key值对应的节点作为过期节点处理。
那么该方法的功能就是两点：
（1）将key、value组成节点放到staleSlot处
（2）如果在i – j的序列中扫描到了过期节点，那么擦除该节点，并从该节点后的第一个null节点开始启发式擦除。
之所以需要向前扫描，是为了避免在扫描过程中对有效节点的rehash后出现由过期节点导致的hash冲突。

扩容

• Entry数组扩容阈值为数组长度的2/3 threshold = len * 2 / 3;

private void set(ThreadLocal<?> key, Object value) {
	// 省略部分代码
    tab[i] = new Entry(key, value);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

private void rehash() {
	// 清除所有过期（STALE状态）的Entry，即key为null的Entry
    expungeStaleEntries();
    // 清除过程中，size会减小，在此处重新计算是否需要扩容
    // 并没有直接使用threshold，而是用更低的threshold（约threshold的3/4）提前触发resize
    if (size >= threshold - threshold / 4)
        resize();
}

private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    int count = 0;

    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        if (e != null) {
            ThreadLocal<?> k = e.get();
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }

    setThreshold(newLen);
    size = count;
    table = newTab;
}

ThreadLocalMap分析