参考文献:
ThreadLocal-面试必问深度解析
手撕面试题ThreadLocal!!!
通常情况下,我们创建的变量是可以被任何一个线程访问并修改的。如果想实现每一个线程都有自己的专属本地变量该如何解决呢? JDK中提供的ThreadLocal
类正是为了解决这样的问题。 ThreadLocal
类主要解决的就是让每个线程绑定自己的值,可以将ThreadLocal
类形象的比喻成存放数据的盒子,盒子中可以存储每个线程的私有数据。
如果你创建了一个ThreadLocal
变量,那么访问这个变量的每个线程都会有这个变量的本地副本,这也是ThreadLocal
变量名的由来。他们可以使用 get()
和 set()
方法来获取默认值或将其值更改为当前线程所存的副本的值,从而避免了线程安全问题。
ThreadLocal用在什么地方?
讨论ThreadLocal用在什么地方前,我们先明确下,如果仅仅就一个线程,那么都不用谈ThreadLocal的,ThreadLocal是用在多线程的场景的!!!
ThreadLocal归纳下来就2类用途:
- 保存线程上下文信息,在任意需要的地方可以获取!!!
- 线程安全的,避免某些情况需要考虑线程安全必须同步带来的性能损失!!!
保存线程上下文信息,在任意需要的地方可以获取
由于ThreadLocal的特性,同一线程在某地方进行设置,在随后的任意地方都可以获取到。从而可以用来保存线程上下文信息。
常用的比如每个请求怎么把一串后续关联起来,就可以用ThreadLocal进行set,在后续的任意需要记录日志的方法里面进行get获取到请求id,从而把整个请求串起来。
还有比如Spring的事务管理,用ThreadLocal存储Connection,从而各个DAO可以获取同一Connection,可以进行事务回滚,提交等操作。
线程安全的,避免某些情况需要考虑线程安全必须同步带来的性能损失
ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。但是ThreadLocal也有局限性,我们来看看阿里规范:
每个线程往ThreadLocal中读写数据是线程隔离,互相之间不会影响的,所以ThreadLocal无法解决共享对象的更新问题!
Thread类中有一个ThreadLocalMap类型的成员变量:threadLocals
/* ThreadLocal values pertaining to this thread.
This map is maintained by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocalMap为ThreadLocal的静态内部类
ThreadLocalMap
ThreadLocalMap的成员变量
// 初始值,必须是2的n次方
private static final int INITIAL_CAPACITY = 16;
// Entry数组,必要时可以扩容,长度是2的n次方
private Entry[] table;
// table中Entry的个数
private int size = 0;
// 扩容的临界值
private int threshold; // Default to 0
// Entry对象
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
Entry继承自WeakReference(弱引用,生命周期只能存活到下次GC前),但只有Key是弱引用类型的,Value并非弱引用。
ThreadLocal#set
public void set(T value) {
//获取当前线程
Thread t = Thread.currentThread();
// 1、获取当前线程上的map
ThreadLocalMap map = getMap(t);
//如果map不为null,则设置值
if (map != null)
//2、调用ThreadLocalMap#set
map.set(this, value);
else
// 3、map为null,初始化并设置值
createMap(t, value);
}
// 1、ThreadLocal#getMap
//根据当前线程获取当前线程上的map
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
//threadLocals定义在Thread中
ThreadLocal.ThreadLocalMap threadLocals = null;
当调用ThreadLocal对象的set方法的时候,会首先获取当前线程上的threadLocals
而我们创建ThreadLocal对象的时候(调用的空参构造器,并没初始化ThreadLocalMap)
即当前线程里的ThreadLocalMap成员变量threadLocals为null,此时才会创建ThreadLocalMap对象
// 3、ThreadLocal#createMap,参数为当前线程和要存入的值
void createMap(Thread t, T firstValue) {
//初始化当前线程的map:threadLocals,参数this当前ThreadLocal对象
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
//构造方法
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//初始化table
table = new Entry[INITIAL_CAPACITY];
//计算索引
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
//设置值
table[i] = new Entry(firstKey, firstValue);
size = 1;
//设置阈值
setThreshold(INITIAL_CAPACITY);
}
// 2、ThreadLocal.ThreadLocalMap#set
private void set(ThreadLocal<?> key, Object value) {
//获取当前的Entry数组
Entry[] tab = table;
//当前数组的长度
int len = tab.length;
//根据key通过hash后& (len-1)找到当前key在数组中的位置
int i = key.threadLocalHashCode & (len-1);
//从i位置开始遍历tab数组
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为null,用新key、value覆盖,同时清理历史key=null的陈旧数据
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
//如果超过阀值,就需要再哈希了
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
//ThreadLocal.ThreadLocalMap#rehash
private void rehash() {
expungeStaleEntries();// 清理一次陈旧数据
// 清理完陈旧数据,如果>= 3/4阀值,就执行扩容,避免迟滞
if (size >= threshold - threshold / 4)
resize();
}
//ThreadLocal.ThreadLocalMap#expungeStaleEntries
//删除陈旧的数据
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)//entry不为空且entry的key为null
expungeStaleEntry(j);//删除指定数组下标的陈旧entry
}
}
//ThreadLocal.ThreadLocalMap#expungeStaleEntry
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
tab[staleSlot].value = null;//删除value
tab[staleSlot] = null;//删除entry
size--;//map的size自减
// 遍历指定删除节点,所有后续节点
Entry e;
int i;
for (i = nextIndex(staleSlot, len);(e = tab[i]) != null; i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) {//key为null,执行删除操作
e.value = null;
tab[i] = null;
size--;
} else {//key不为null,重新计算下标
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {//如果不在同一个位置
tab[i] = null;//把老位置的entry置null(删除)
// 从h开始往后遍历,一直到找到空为止,插入
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
//ThreadLocal.ThreadLocalMap#resize
//把table扩容2倍,并把老数据重新哈希散列进新table
private void resize() {
Entry[] oldTab = table;
int oldLen = oldTab.length;
int newLen = oldLen * 2;
Entry[] newTab = new Entry[newLen];
int count = 0;
// 遍历Entry[]数组
for (int j = 0; j < oldLen; ++j) {
Entry e = oldTab[j];
if (e != null) {
ThreadLocal<?> k = e.get();
if (k == null) {// 如果key=null
e.value = null; // 把value也置null,有助于GC回收对象
} else {// 如果key!=null
int h = k.threadLocalHashCode & (newLen - 1);// 计算hash值
while (newTab[h] != null)// 如果这个位置已使用
h = nextIndex(h, newLen);// 线性往后查询,直到找到一个没有使用的位置,h递增
newTab[h] = e;//在第一个空节点上塞入Entry e
count++;// 计数++
}
}
}
setThreshold(newLen);// 设置新的阈值(实际set方法用了2/3的newLen作为阈值)
size = count;// 设置ThreadLocalMap的元素个数
table = newTab;// 把新table赋值给ThreadLocalMap的Entry[] table
}
ThreadLocal#get
public T get() {
//同set方法类似获取对应线程中的ThreadLocalMap实例
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//为空返回初始化值
return setInitialValue();
}
//java.lang.ThreadLocal#setInitialValue
private T setInitialValue() {
//获取初始化值,默认为null(如果没有子类进行覆盖)
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
//不为空不用再初始化,直接调用set操作设值
if (map != null)
//ThreadLocal.ThreadLocalMap#set
map.set(this, value);
else
//第一次初始化
createMap(t, value);
return value;
}
private ThreadLocal.ThreadLocalMap.Entry getEntry(ThreadLocal<?> key) {
//根据key计算索引,获取entry
int i = key.threadLocalHashCode & (table.length - 1);
ThreadLocal.ThreadLocalMap.Entry e = table[i];
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}
/**
* 通过直接计算出来的key找不到对于的value的时候适用这个方法.
*/
private ThreadLocal.ThreadLocalMap.Entry getEntryAfterMiss(ThreadLocal<?> key, int i, ThreadLocal.ThreadLocalMap.Entry e) {
ThreadLocal.ThreadLocalMap.Entry[] tab = table;
int len = tab.length;
while (e != null) {
ThreadLocal<?> k = e.get();
if (k == key)
return e;
if (k == null)
//清除无效的entry
expungeStaleEntry(i);
else
//基于线性探测法向后扫描
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
ThreadLocal#remove
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
private void remove(ThreadLocal<?> key) {
ThreadLocal.ThreadLocalMap.Entry[] tab = table;
int len = tab.length;
//计算索引
int i = key.threadLocalHashCode & (len-1);
//进行线性探测,查找正确的key
for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
if (e.get() == key) {
//调用weakrefrence的clear()清除引用
e.clear();
//连续段清除
expungeStaleEntry(i);
return;
}
}
}
简单测试
public class ThreadLocalTest2 {
private static ThreadLocal<Integer> threadLocal1 = new ThreadLocal<>();
private static ThreadLocal<String> threadLocal2 = new ThreadLocal<>();
public static void main(String[] args) {
new Thread(() -> {
try {
for (int i = 0; i < 10; i++) {
/**
* set是set进当前线程的ThreadLocalMap,key是ThreadLocal对象
* 所以一个ThreadLocal对象连续调用set()方法时,会覆盖已经保存的值
* 如果一个线程要保存多个本地线程变量,则应该使用多个ThreadLocal对象
*/
threadLocal1.set(i);
threadLocal2.set(i+"_@");
System.out.println(Thread.currentThread().getName() + ":数字——" + threadLocal1.get());
System.out.println(Thread.currentThread().getName() + ":字符——" + threadLocal2.get());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} finally {
threadLocal1.remove();
threadLocal2.remove();
}
}, "线程1").start();
new Thread(() -> {
try {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + ":" + threadLocal1.get());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} finally {
threadLocal1.remove();
}
}, "线程2").start();
}
}
线程1:数字——0
线程1:字符——0_@
线程2:null
线程2:null
线程1:数字——1
线程1:字符——1_@
线程2:null
线程1:数字——2
线程1:字符——2_@
线程2:null
线程1:数字——3
线程1:字符——3_@
线程2:null
线程1:数字——4
线程1:字符——4_@
线程1:数字——5
线程1:字符——5_@
线程2:null
线程2:null
线程1:数字——6
线程1:字符——6_@
线程2:null
线程1:数字——7
线程1:字符——7_@
线程2:null
线程1:数字——8
线程1:字符——8_@
线程2:null
线程1:数字——9
线程1:字符——9_@
弱引用也是用来描述非必需对象的,当JVM进行垃圾回收时,无论内存是否充足,该对象仅仅被弱引用关联,那么就会被回收。
当仅仅只有ThreadLocalMap中的Entry的key指向ThreadLocal的时候,ThreadLocal会被进行回收,ThreadLocal被垃圾回收后,在ThreadLocalMap里对应的Entry的键值会变成null,但是Entry是强引用,那么Entry里面存储的Object,并没有办法进行回收,所以ThreadLocalMap 做了一些额外的回收工作。
由于线程的生命周期很长,如果我们往ThreadLocal里面set了很大很大的Object对象,虽然set、get等等方法在特定的条件会调用进行额外的清理,但是ThreadLocal被垃圾回收后,在ThreadLocalMap里对应的Entry的键值会变成null,但是后续在也没有操作set、get等方法了,应该在我们不使用的时候,主动调用remove方法进行清理。
这里把ThreadLocal定义为static还有一个好处就是,由于ThreadLocal有强引用在,那么在ThreadLocalMap里对应的Entry的键会永远存在,那么执行remove的时候就可以正确进行定位到并且删除