并发[2]-ThreadLocal - TheEmbers.devFun

说明

ThreadLocal 的作用是提供线程内的局部变量，这种变量在多线程环境下访问时能够保证各个线程里变量的独立性。

基本使用

public class ThreadLocalDemo {

    public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>();
    public static ThreadLocal<User> threadLocalUser = new ThreadLocal<User>();

	public static void main(String args[]) {
		threadLocal.set(100);	// 保存值
		System.out.println(threadLocal.get());	// 获取值

		User user = new User();
		user.setName("Tom");
		user.setAge(25);
		threadLocalUser.set(user);	// 保存值
		System.out.println(threadLocalUser.get());	// 获取值
	}

	static class User{
		String name;
		Integer age;

		// geter&seter..

		@Override
		public String toString() {
			return "User [name=" + name + ", age=" + age + "]";
		}

	}
}

// 输出结果
// 100
// User [name=Tom, age=25]

源码解析

ThreadLocal 的定义

ThreadLocal 提供了线程局部变量。能使线程中的某个值与保存值的对象关联起来。ThreadLocal 提供了 get 与 set 等访问接口或方法，这些方法为每个使用该变量的线程都存有一份独立的副本（即每个线程的 threadLocals 属性），因此 get 总是返回由当前执行线程在调用 set 时设置的最新值。

只要线程处于活动状态并且 Threadocal 实例可以访问，每个线程就拥有对其线程局部变量副本的隐式引用；在一个线程消失之后，线程本地实例的所有副本都会被垃圾收集（除非存在对这些副本的其他引用）。

ThreadLocal 的 hashcode（threadLocalHashCode）是从 0 开始，每新建一个 ThreadLocal，对应的 hashcode 就加 0x61c88647。如下：

private final int threadLocalHashCode = nextHashCode();

// AtomicInteger类型，从0开始
private static AtomicInteger nextHashCode =
    new AtomicInteger();

// hash code每次增加1640531527
private static final int HASH_INCREMENT = 0x61c88647;

// 下一个hash code
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);

ThreadLocalMap 的定义

ThreadLocalMap 是一个自定义哈希映射，仅用于维护线程本地变量值。ThreadLocalMap 是 ThreadLocal 的内部类，主要有一个 Entry 数组，Entry 的 key 为 ThreadLocal，value 为 ThreadLocal 对应的值。每个线程都有一个 ThreadLocalMap 类型的 threadLocals 变量。

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

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

set()方法

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t); // 获取当前线程的ThreadLocalMap
    // 当前线程的ThreadLocalMap不为空则调用set方法, this为调用该方法的ThreadLocal对象
    if (map != null)
        map.set(this, value); // --> 代码块 1
    // map为空则调用createMap方法创建一个新的ThreadLocalMap, 并新建一个Entry放入该
    // ThreadLocalMap, 调用set方法的ThreadLocal和传入的value作为该Entry的key和value
    else
        createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;	// 返回线程t的threadLocals属性
}

先拿到当前线程，再使用 getMap 方法拿到当前线程的 threadLocals 变量
如果 threadLocals 不为空，则将当前 ThreadLocal 作为 key，传入的值作为 value，调用 set 方法（见下文代码块 1 详解）插入 threadLocals。
如果 threadLocals 为空则调用创建一个 ThreadLocalMap，并新建一个 Entry 放入该 ThreadLocalMap, 调用 set 方法的 ThreadLocal 和传入的 value 作为该 Entry 的 key 和 value

注意此处的 threadLocals 变量是一个 ThreadLocalMap，是 Thread 的一个局部变量，因此它只与当前线程绑定。

代码块 1：set 方法

private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);  // 计算出索引的位置

    // 从索引位置开始遍历,由于不是链表结构,因此通过nextIndex方法来寻找下一个索引位置
    for (Entry e = tab[i];
        e != null;	// 当遍历到的Entry为空时结束遍历
        e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get(); // 拿到Entry的key，也就是ThreadLocal

        // 该Entry的key和传入的key相等, 则用传入的value替换掉原来的value
        if (k == key) {
            e.value = value;
            return;
        }

        // 该Entry的key为空, 则代表该Entry需要被清空,
        // 调用replaceStaleEntry方法
        if (k == null) {
        	// 该方法会继续寻找传入key的安放位置, 并清理掉key为空的Entry
            replaceStaleEntry(key, value, i); // --> 代码块 2
            return;
        }
    }

    // 寻找到一个空位置,　则放置在该位置上
    tab[i] = new Entry(key, value);
    int sz = ++size;
    // cleanSomeSlots是用来清理掉key为空的Entry,如果此方法返回true,则代表至少清理
    // 了1个元素, 则此次set必然不需要扩容, 如果此方法返回false则判断sz是否大于阈值
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();   // 扩容
}

通过传入的 key 的 hashCode 计算出索引的位置
从索引位置开始遍历，由于不是链表结构，因此通过 nextIndex 方法来寻找下一个索引位置
如果找到某个 Entry 的 key 和传入的 key 相同，则用传入的 value 替换掉该 Entry 的 value。
如果遍历到某个 Entry 的 key 为空，则调用 replaceStaleEntry 方法（见下文代码块 2 详解）
如果通过 nextIndex 寻找到一个空位置（代表没有找到 key 相同的），则将元素放在该位置上
调用 cleanSomeSlots 方法清理 key 为 null 的 Entry，并判断是否需要扩容，如果需要则调用 rehash 方法进行扩容（见下文 rehash 方法详解）。

代码块 2：replaceStaleEntry 方法

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

    int slotToExpunge = staleSlot;	// 清除元素的开始位置（记录索引位置最前面的）
    // 向前遍历，直到遇到Entry为空
    for (int i = prevIndex(staleSlot, len);
        (e = tab[i]) != null;
        i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;	// 记录最后一个key为null的索引位置

    // Find either the key or trailing null slot of run, whichever
    // occurs first
    for (int i = nextIndex(staleSlot, len); // 向后遍历，直到遇到Entry为空
        (e = tab[i]) != null;
        i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();

        // 该Entry的key和传入的key相等, 则将传入的value替换掉该Entry的value
        if (k == key) {
            e.value = value;

            // 将i位置和staleSlot位置的元素对换（staleSlot位置较前，是要清除的元素）
            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

            // 如果相等, 则代表上面的向前寻找key为null的遍历没有找到，
            // 即staleSlot位置前面的元素没有需要清除的，此时将slotToExpunge设置为i,
            // 因为原staleSlot的元素已经被放到i位置了，这时位置i前面的元素都不需要清除
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            // 从slotToExpunge位置开始清除key为空的Entry
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        // 如果第一次遍历到key为null的元素，并且上面的向前寻找key为null的遍历没有找到，
        // 则将slotToExpunge设置为当前的位置
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // 如果key没有找到，则新建一个Entry，放在staleSlot位置
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    // 如果slotToExpunge!=staleSlot，代表除了staleSlot位置还有其他位置的元素需要清除
    // 需要清除的定义：key为null的Entry，调用cleanSomeSlots方法清除key为null的Entry
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); // --> 代码块 3
}

slotToExpunge 始终记录着需要清除的元素的最前面的位置（即 slotToExpunge 前面的元素是不需要清除的）
从位置 staleSlot 向前遍历，直到遇到 Entry 为空，用 staleSlot 记录最后一个 key 为 null 的索引位置（也就是遍历过位置最前的 key 为 null 的位置）
从位置 staleSlot 向后遍历，直到遇到 Entry 为空，如果遍历到 key 和入参 key 相同的，则将入参的 value 替换掉该 Entry 的 value，并将 i 位置和 staleSlot 位置的元素对换（staleSlot 位置较前，是要清除的元素），遍历的时候判断 slotToExpunge 的值是否需要调整，最后调用 expungeStaleEntry 方法（见下文 expungeStaleEntry 方法详解）和 cleanSomeSlots 方法（见下文代码块 3 详解）清除 key 为 null 的元素。
如果 key 没有找到，则使用入参的 key 和 value 新建一个 Entry，放在 staleSlot 位置
判断是否还有其他位置的元素 key 为 null，如果有则调用 expungeStaleEntry 方法和 cleanSomeSlots 方法清除 key 为 null 的元素

代码块 3：cleanSomeSlots 方法

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) {	// 遍历到key为null的元素
            n = len;	// 重置n的值
            removed = true;	// 标志有移除元素
            i = expungeStaleEntry(i);	// 移除i位置及之后的key为null的元素
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

从 i 开始，清除 key 为空的 Entry，遍历次数由当前的 table 长度决定，当遍历到一个 key 为 null 的元素时，调用 expungeStaleEntry 清除，并将遍历次数重置。至于为什么使用 table 长度来决定遍历次数，官方给出的解释是这个方法简单、快速，并且效果不错。

get()方法

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
    	//调用getEntry方法, 通过调用get()方法的ThreadLocal获取对应的Entry
        ThreadLocalMap.Entry e = map.getEntry(this); // --> 代码块 5
        if (e != null) {    //Entry不为空则代表找到目标Entry, 返回该Entry的value值
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();   //该线程的ThreadLocalMap为空则初始化一个 --> 代码块 4
}

跟 set 方法差不多，先拿到当前的线程，再使用 getMap 方法拿到当前线程的 threadLocals 变量
如果 threadLocals 不为空，则将调用 get 方法的 ThreadLocal 作为 key，调用 getEntry 方法（见下文代码块 5 详解）找到对应的 Entry。
如果 threadLocals 为空或者找不到目标 Entry，则调用 setInitialValue 方法（见下文代码块 4 详解）进行初始化。

代码块 4：setInitialValue 方法

private T setInitialValue() {
    T value = initialValue();	// 默认null，需要用户自己重写该方法，
    Thread t = Thread.currentThread();	// 当前线程
    ThreadLocalMap map = getMap(t);	// 拿到当前线程的threadLocals
    // threadLocals不为空则将当前的ThreadLocal作为key，null作为value，插入到ThreadLocalMap
    if (map != null)
        map.set(this, value);
    // threadLocals为空则调用创建一个ThreadLocalMap，并新建一个Entry放入该ThreadLocalMap,
    // 调用set方法的ThreadLocal和value作为该Entry的key和value
    else
        createMap(t, value);
    return value;
}

如果是 threadLocals 为空，创建一个新的 ThreadLocalMap，并将当前的 ThreadLocal 作为 key，null 作为 value，插入到新创建的 ThreadLocalMap，并返回 null。
如果 threadLocals 不为空，则将当前的 ThreadLocal 作为 key，null 作为 value，插入到 threadLocals。
注意上面的 initialValue()方法为 protected，如果希望线程局部变量具有非 null 的初始值，则必须对 ThreadLocal 进行子类化，并重写此方法。

代码块 5：getEntry 方法

private Entry getEntry(ThreadLocal<?> key) {
	//根据hash code计算出索引位置
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    // 如果该Entry的key和传入的key相等, 则为目标Entry, 直接返回
    if (e != null && e.get() == key)
        return e;
    // 否则，e不是目标Entry, 则从e之后继续寻找目标Entry
    else
        return getEntryAfterMiss(key, i, e); // --> 代码块 6
}

根据 hash code 计算出索引位置
如果该索引位置 Entry 的 key 和传入的 key 相等，则为目标 Entry，直接返回
否则，e 不是目标 Entry，调用 getEntryAfterMiss 方法（见下文代码块 6 详解）继续遍历。

代码块 6：getEntryAfterMiss 方法

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

    while (e != null) {
        ThreadLocal<?> k = e.get();
        // 找到目标Entry，直接返回
        if (k == key)
            return e;
        // 调用expungeStaleEntry清除key为null的元素
        if (k == null)
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);  // 下一个索引位置
        e = tab[i]; // 下一个遍历的Entry
    }
    return null;    // 找不到, 返回空
}

从元素 e 开始向后遍历，如果找到目标 Entry 元素直接返回；如果遇到 key 为 null 的元素，调用 expungeStaleEntry 方法（见下文 expungeStaleEntry 方法详解）进行清除；否则，遍历到 Entry 为 nu

remove()方法

public void remove() {
	// 获取当前线程的ThreadLocalMap
	ThreadLocalMap m = getMap(Thread.currentThread());
	if (m != null)
		m.remove(this);    // 调用此方法的ThreadLocal作为入参，调用remove方法
}

private void remove(ThreadLocal<?> key) {
    Entry[] tab = table;
    int len = tab.length;
    // 根据hashCode计算出当前ThreadLocal的索引位置
    int i = key.threadLocalHashCode & (len-1);
    // 从位置i开始遍历，直到Entry为null
    for (Entry e = tab[i];
        e != null;
        e = tab[i = nextIndex(i, len)]) {
        if (e.get() == key) {   // 如果找到key相同的
            e.clear(); 	// 则调用clear方法, 该方法会把key的引用清空
            expungeStaleEntry(i);//调用expungeStaleEntry方法清除key为null的Entry
            return;
        }
    }
}

方法很简单，拿到当前线程的 threadLocals 属性，如果不为空，则将 key 为当前 ThreadLocal 的键值对移除，并且会调用 expungeStaleEntry 方法清除 key 为空的 Entry。

expungeStaleEntry 方法

// 从staleSlot开始, 清除key为空的Entry, 并将不为空的元素放到合适的位置，最后返回Entry为空的位置
private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    // expunge entry at staleSlot
    tab[staleSlot].value = null;    // 将tab上staleSlot位置的对象清空
    tab[staleSlot] = null;
    size--;

    // Rehash until we encounter null
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len); // 遍历下一个元素, 即(i+1)%len位置的元素
        (e = tab[i]) != null;	// 遍历到Entry为空时, 跳出循环并返回索引位置
        i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        if (k == null) {    // 当前遍历Entry的key为空, 则将该位置的对象清空
            e.value = null;
            tab[i] = null;
            size--;
        } else {    // 当前遍历Entry的key不为空
            int h = k.threadLocalHashCode & (len - 1);  // 重新计算该Entry的索引位置
            if (h != i) {   // 如果索引位置不为当前索引位置i
                tab[i] = null;  // 则将i位置对象清空, 替当前Entry寻找正确的位置

                // 如果h位置不为null，则向后寻找当前Entry的位置
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

从 staleSlot 开始，清除 key 为 null 的 Entry，并将不为空的元素放到合适的位置，最后遍历到 Entry 为空的元素时，跳出循环返回当前索引位置。

set、get、remove 方法，在遍历的时候如果遇到 key 为 null 的情况，都会调用 expungeStaleEntry 方法来清除 key 为 null 的 Entry。

rehash 方法

private void rehash() {
    expungeStaleEntries();  // 调用expungeStaleEntries方法清理key为空的Entry

    // 如果清理后size超过阈值的3/4, 则进行扩容
    if (size >= threshold - threshold / 4)
        resize();
}

/**
 * Double the capacity of the table.
 */
private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;	// 新表长度为老表2倍
    Entry[] newTab = new Entry[newLen];	// 创建新表
    int count = 0;

    for (int j = 0; j < oldLen; ++j) {	// 遍历所有元素
        Entry e = oldTab[j];	// 拿到对应位置的Entry
        if (e != null) {
            ThreadLocal<?> k = e.get();
            if (k == null) {	// 如果key为null，将value清空
                e.value = null; // Help the GC
            } else {
            	// 通过hash code计算新表的索引位置
                int h = k.threadLocalHashCode & (newLen - 1);
                // 如果新表的该位置已经有元素，则调用nextIndex方法直到寻找到空位置
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;	// 将元素放在对应位置
                count++;
            }
        }
    }

    setThreshold(newLen);	// 设置新表扩容的阈值
    size = count;	// 更新size
    table = newTab;	// table指向新表
}

调用 expungeStaleEntries 方法（该方法和 expungeStaleEntry 类似，只是把搜索范围扩大到整个表）清理 key 为空的 Entry
如果清理后 size 超过阈值的 3/4，则进行扩容。
新表长度为老表 2 倍，创建新表。
遍历老表所有元素，如果 key 为 null，将 value 清空；否则通过 hash code 计算新表的索引位置 h，如果 h 已经有元素，则调用 nextIndex 方法直到寻找到空位置，将元素放在新表的对应位置。
设置新表扩容的阈值、更新 size、table 指向新表。

内存泄漏问题

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

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

从上面源码可以看出，ThreadLocalMap 使用 ThreadLocal 的弱引用作为 Entry 的 key，如果一个 ThreadLocal 没有外部强引用来引用它，下一次系统 GC 时，这个 ThreadLocal 必然会被回收，这样一来，ThreadLocalMap 中就会出现 key 为 null 的 Entry，就没有办法访问这些 key 为 null 的 Entry 的 value。

我们上面介绍的 get、set、remove 等方法中，都会对 key 为 null 的 Entry 进行清除（expungeStaleEntry 方法，将 Entry 的 value 清空，等下一次垃圾回收时，这些 Entry 将会被彻底回收）。

但是如果当前线程一直在运行，并且一直不执行 get、set、remove 方法，这些 key 为 null 的 Entry 的 value 就会一直存在一条强引用链：Thread Ref -> Thread -> ThreadLocalMap -> Entry -> value，导致这些 key 为 null 的 Entry 的 value 永远无法回收，造成内存泄漏。

如何避免内存泄漏

为了避免这种情况，我们可以在使用完 ThreadLocal 后，手动调用 remove 方法，以避免出现内存泄漏。

文章目录

说明