ThreadLocal 源码解析

一. 前言

二. 基本使用

三. 源码解析

3.1. 成员变量

3.6. expungeStaleEntry() 方法

一. 前言

ThreadLocal的作用是提供线程内的局部变量，这种变量在多线程环境下访问时能够保证各个线程里变量的独立性。ThreadLocal无论在项目开发还是面试中都会经常碰到，本文就ThreadLocal的使用、主要方法源码详解、内存泄漏问题展开讨论。

ThreadLocal是一个将在多线程中为每一个线程创建单独的变量副本的类；当使用ThreadLocal来维护变量时，ThreadLocal会为每个线程创建单独的变量副本，避免因多线程操作共享变量而导致的数据不一致的情况。

二. 基本使用


public class ThreadLocalDemo {
    static ThreadLocal threadLocal = new ThreadLocal<>();
 
    static ThreadLocal userThreadLocal = new ThreadLocal<>();
 
    public static void main(String[] args) {
        threadLocal.set(100); // 保存值
        System.out.println(threadLocal.get()); // 获取值
 
        User user = new User();
        user.setName("流华追梦");
        user.setAge(25);
        userThreadLocal.set(user); // 保存值
        System.out.println(userThreadLocal.get()); // 获取值
    }
 
    static class User {
        String name;
 
        Integer age;
 
        public String getName() {
            return name;
        }
 
        public void setName(String name) {
            this.name = name;
        }
 
        public Integer getAge() {
            return age;
        }
 
        public void setAge(Integer age) {
            this.age = age;
        }
    }
}
 
// 输出
100
User [name=流华追梦, age=25]

三. 源码解析

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

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

3.1. 成员变量


// 哈希Code
private final int threadLocalHashCode = nextHashCode();
 
/**
 * AtomicInteger类型，从0开始
 */
private static AtomicInteger nextHashCode =
	new AtomicInteger();
 
/**
 * 哈希Code每次增加的值为1640531527
 */
private static final int HASH_INCREMENT = 0x61c88647;
 
/**
 * 下一个哈希Code
 */
private static int nextHashCode() {
	return nextHashCode.getAndAdd(HASH_INCREMENT);
}

从上面的定义可以知道，ThreadLocal的hashcode（threadLocalHashCode）是从0开始，每新建一个ThreadLocal，对应的hashcode就加0x61c88647。

3.2. ThreadLocalMap


static class ThreadLocalMap {    
	static class Entry extends WeakReference> {
		/** The value associated with this ThreadLocal. */
		Object value;
 
		Entry(ThreadLocal k, Object v) {
			super(k);
			value = v;
		}
	}
	
	......
}

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

3.3. 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);
	// map为空则调用createMap方法创建一个新的ThreadLocalMap，
	// 并将调用set()方法的ThreadLocal和传入的value作为Entry的key和value，
	// 新建一个Entry放入该ThreadLocalMap
	else
		createMap(t, value);
}
 
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals; // 返回线程t的threadLocals属性
}

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

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

代码块1：


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);
			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(); // 扩容
}

1、通过传入的key的hashCode计算出索引的位置
2、从索引位置开始遍历，由于不是链表结构，因此通过nextIndex方法来寻找下一个索引位置
3、如果找到某个Entry的key和传入的key相同，则用传入的value替换掉该Entry的value。
4、如果遍历到某个Entry的key为空，则调用replaceStaleEntry方法（见下文代码块2详解）
5、如果通过nextIndex寻找到一个空位置（代表没有找到key相同的），则将元素放在该位置上
6、调用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的索引位置
 
	for (int i = nextIndex(staleSlot, len);
		 (e = tab[i]) != null;
		 i = nextIndex(i, len)) { // 向后遍历，直到遇到Entry为空
		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);
}

1、slotToExpunge始终记录着需要清除的元素的最前面的位置（即slotToExpunge前面的元素是不需要清除的）。
2、从位置staleSlot向前遍历，直到遇到Entry为空，用staleSlot记录最后一个key为null的索引位置（也就是遍历过位置最前的key为null的位置）。
3、从位置staleSlot向后遍历，直到遇到Entry为空，如果遍历到key和入参key相同的，则将入参的value替换掉该Entry的value，并将i位置和staleSlot位置的元素对换（staleSlot位置较前，是要清除的元素），遍历的时候判断slotToExpunge的值是否需要调整，最后调用expungeStaleEntry方法（见下文expungeStaleEntry方法详解）和cleanSomeSlots方法（见下文代码块3详解）清除key为null的元素。
4、如果key没有找到，则使用入参的key和value新建一个Entry，放在staleSlot位置。
5、判断是否还有其他位置的元素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长度来决定遍历次数，官方给出的解释是这个方法简单、快速，并且效果不错。

3.4. 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);
		if (e != null) { // Entry不为空则代表找到目标Entry，返回该Entry的value值
			@SuppressWarnings("unchecked")
			T result = (T)e.value;
			return result;
		}
	}
	return setInitialValue(); // 该线程的ThreadLocalMap为空则初始化一个
}

1、跟set方法差不多，先拿到当前的线程，再使用getMap方法拿到当前线程的threadLocals变量。
2、如果threadLocals不为空，则将调用get方法的ThreadLocal作为key，调用getEntry方法（见下文代码块5详解）找到对应的Entry。
3、如果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;
}

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

代码块5：getEntry方法


private Entry getEntry(ThreadLocal key) {
    // 根据哈希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);
}

1、根据hash code计算出索引位置。
2、如果该索引位置Entry的key和传入的key相等，则为目标Entry，直接返回。
3、否则，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为null时，结束遍历，返回null。

3.5. 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为null的Entry。

3.6. expungeStaleEntry() 方法


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为空的元素时，跳出循环返回当前索引位置。

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

3.7. 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 {
			    // 通过哈希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指向新表
}

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

四. 功能测试


public class ThreadLocalTest {
    private static ThreadLocal threadLocal = new ThreadLocal<>();
 
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new ThreadOne(); // 线程1
        Thread thread2 = new ThreadTwo(); // 线程2
 
        thread2.start(); // 线程2开始执行
        TimeUnit.MILLISECONDS.sleep(100); // 睡眠，以等待线程2执行完毕
 
        thread1.start(); // 线程1开始执行
        TimeUnit.MILLISECONDS.sleep(100); // 睡眠，以等待线程1执行完毕
 
        // 此时线程1和线程2都已经设置过值，此处输出为空，
        // 说明子线程与父线程之间也是互不影响的
        System.out.println("main：" + threadLocal.get());
    }
 
    // 线程1
    private static class ThreadOne extends Thread {
        @Override
        public void run() {
            // 此时线程2已经调用过set(456)，此处输出为空，说明线程之间是互不影响的
            System.out.println("ThreadOne：" + threadLocal.get());
            threadLocal.set(123);
            System.out.println("ThreadOne：" + threadLocal.get());
        }
    }
 
    // 线程2
    private static class ThreadTwo extends Thread {
        @Override
        public void run() {
            threadLocal.set(456); // 设置当前threadLocal的值为456
            System.out.println("ThreadTwo：" + threadLocal.get());
        }
    }
}


输出结果：
 
ThreadTo: 456
ThreadOne: null
ThreadOne: 123
main: null

从输出结果可以看出，线程1、线程2和主线程之间是彼此互不影响的。

五. 内存泄漏问题


static class Entry extends WeakReference> {
	/** 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方法，以避免出现内存泄漏。

六. 总结

1、每个线程都有一个 ThreadLocalMap 类型的 threadLocals 属性。
2、ThreadLocalMap 类相当于一个Map，key 是 ThreadLocal 本身，value 就是我们的值。
3、当我们通过 threadLocal.set(new Integer(123)); ，我们就会在这个线程中的 threadLocals 属性中放入一个键值对，key 是这个threadLocal.set(new Integer(123)) 的 threadlocal，value就是值new Integer(123)。
4、当我们通过 threadlocal.get() 方法的时候，首先会根据这个线程得到这个线程的 threadLocals 属性，然后由于这个属性放的是键值对，我们就可以根据键 threadlocal 拿到值。注意，这时候这个键 threadlocal 和我们 set 方法的时候的那个键 threadLocal 是一样的，所以我们能够拿到相同的值。
5、ThreadLocalMap 的get/set/remove方法跟HashMap的内部实现都基本一样，通过 "key.threadLocalHashCode & (table.length - 1)" 运算式计算得到我们想要找的索引位置，如果该索引位置的键值对不是我们要找的，则通过nextIndex方法计算下一个索引位置，直到找到目标键值对或者为空。
6、hash冲突：在HashMap中相同索引位置的元素以链表形式保存在同一个索引位置；而在ThreadLocalMap中，没有使用链表的数据结构，而是将（当前的索引位置+1）对length取模的结果作为相同索引元素的位置：源码中的nextIndex()方法，可以表达成如下公式：如果i为当前索引位置，则下一个索引位置 = (i + 1 < len) ? i + 1 : 0。

相关阅读:
联想服务配置
 CSS 常用样式——定位属性类型及特点
 扩展运算符
 Protobuf compiler version 3.19.1 doesn‘t match library version 3.0.0
组合数学——二项式反演
 2.23作业
 JDK安装教程
 git缓存命令（git stash）
单片机通用Bootloader框架-优化
 小程序授权获取头像
原文地址：https://blog.csdn.net/mrluo735/article/details/134072312