ThreadLocal
1.ThreadLocal简介
ThreadLocal
是一个通过线程隔离的方式解决多线程操作共享资源造成数据不一致问题的类。
ThreadLocal
通过在多线程环境下为每一个线程创建单独的变量副本,线程之间的变量副本互不影响,每个线程拥有自己的变量副本因此就不存在多线程间共享的问题,从而保证线程安全。(以空间换时间)
ThreadLocal
维护的变量称为线程局部变量,该变量有两个特点:
- 每个线程内都有自己的线程局部变量,且只能访问自己的,不能访问其他线程的
ThreadLocal
维护的变量被private static
修饰,当一个线程销毁时其所有的ThreadLocal
变量都会被回收
ThreadLocal
适用于每个线程需要自己独立的数据副本且可以在多个方法中使用,即变量在线程之间隔离而在方法或类之间共享的场景。
2.常用方法API
方法 | 说明 |
---|---|
get() | 返回当前线程的ThreadLocal 变量副本中的值,如果当前线程没有该变量就调用初始化方法返回初始值 |
set(T value) | 将当前线程的ThreadLocal 变量副本中的值指定为value |
remove() | 移除当前线程的ThreadLocal 变量 |
3.实现原理
ThreadLocal实现线程隔离的基本原理
ThreadLocal
本身不存放数据,使用线程Thread
中的threadLocals
属性,(ThreadLocal是Thread中属性 threadLocals的管理者)threadLocals
属性对应在ThreadLocal
中定义的ThreadLocalMap
对象。
在调用 ThreadLocal
的set()
方法时,会将自身的引用(this
)作为key
,用户传入的值作为value
存入ThreadLocalMap
中。这样每个线程的读写操作都是基于线程本身的一个私有的副本,线程之间的数据是相互隔离的 ,相互不影响。
1.get()
方法
返回当前线程的ThreadLocal
变量副本中的值,如果当前线程没有该变量就初始化为null
返回,如果ThreadLocals属性没有被创建,就新创建一个ThreadLocalMap
,并且创建一个ThreadLocal变量存入map中
public T get() {
// 获取当前线程 t
Thread t = Thread.currentThread();
// 从当前线程t中获取threadlocals属性
ThreadLocalMap map = getMap(t);
// 如果不为null (已经初始化)
if (map != null) {
// 获取以当前ThreadLocal对象为key的值(如果不存在就创建一个ThreadLocal变量)
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
// 如果value不为null就返回
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//如果当前线程的threadlocals属性没有被创建,就调用setInitialValue()方法创建
return setInitialValue();
}
setInitialValue()
初始化方法
private T setInitialValue() {
// value赋值为初始化方法值, 默认为null可以进行方法重写
T value = initialValue();
// 获取当前线程t
Thread t = Thread.currentThread();
// 获取当前线程t的threadlocals属性也就是map集合
ThreadLocalMap map = getMap(t);
// map不为null 添加key - value
if (map != null) {
map.set(this, value);
} else {
// map为null,创建当前线程 t的 map并添加key - value
createMap(t, value);
}
if (this instanceof TerminatingThreadLocal) {
TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
}
return value;
}
2.set()
方法
将当前线程的ThreadLocal
变量副本中的值指定为value
public void set(T value) {
// 获取当前线程t
Thread t = Thread.currentThread();
// 获取当前线程t的 threadLocals属性 即map
ThreadLocalMap map = getMap(t);
// map不为null,添加key - value
if (map != null)
map.set(this, value);
// map为null,创建当前线程t的map并添加key - value
else
createMap(t, value);
}
3.remove()
方法
移除当前线程的ThreadLocal
变量
public void remove() {
// 获取当前线程的threadlocals属性 即map集合
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null) {
// map不为null就将 ThreadLocal变量(this)移除
m.remove(this);
}
}
4.ThreadLocalMap
ThreadLocalMap
内部维护了一个Entry
数组table
来存储key - value
,且 ThreadLocalMap
没有实现Map
接口,因此Entry
数组并非链表形式,而是每个数组下标位置存储一个Entry
继承WeakReference
类,表明ThreadLocal
对象为弱引用
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
private Entry[] table;
/*
.......
*/
}
ThreadLocalMap
中的set()
方法
向ThreadLocalMap
中添加key - value
private void set(ThreadLocal<?> key, Object value) {
// We don't use a fast path as with get() because it is at
// least as common to use set() to create new entries as
// it is to replace existing ones, in which case, a fast
// path would fail more often than not.
Entry[] tab = table;
int len = tab.length;
// 计算哈希值 与 数组下标 -1 得到key对应数组中的位置
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
// 如果当前下标位置 存在相同的key 就进行覆盖
if (k == key) {
e.value = value;
return;
}
// 如果当前下标对应的key不存在,那么直接将当前key- value存入数组
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
// 重哈希策略,采用 冲突位置的下一个空的位置存储 并且清理完无用条目(ThreadLocal被回收的 // 条目)、且数组中的数据大小 ≥ 阈值的时候对当前的Table进行重新哈希
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
getEntry()
方法
根据key
获取ThreadLocalMap
中的Entry
private Entry getEntry(ThreadLocal<?> key) {
// 计算key对应的数组下标
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
// 如果数组下标i位置的Entry 不为null 且键等于当前key 返回Entry
if (e != null && e.get() == key)
return e;
else
// 否则 查找后续位置
return getEntryAfterMiss(key, i, e);
}
4.内存泄漏
ThreadLocal会造成内存泄漏
由于ThreadLocal
对象是弱引用,如果没有外部的强引用指向,会导致ThreadLocal
对象被回收,Entry
中的key
变为空,此时如果value
没有外部引用指向,value
就永远访问不到了,(按理应该被GC回收,但是由于Entry
对象table
数组还在强引用value
)此时会发生内存泄漏,value
成为永远无法访问但又永远无法回收的对象(除非线程被销毁,但是由于出于系统性能的考虑线程不宜频繁的创建和销毁,经常使用线程池,这样线程的生命周期变大,内存泄漏的影响就会变大)
造成内存泄漏的原因总结:
ThreadLocals
对象中的Entry
对象不再使用后,如果没有及时清除Entry
对象,而程序自身也无法通过垃圾回收机制自动清除,就可能导致内存泄漏
避免内存泄漏
每次使用完ThreadLocal
都调用remove()
方法清除数据
将ThreadLocal
变量定义为static final
避免频繁的创建ThreadLocal
对象(比如可以单独创建一个until
类使用ThreadLocal
)
ThreadLocal
内部的优化
-
调用
set()
方法时,会采样清理、全量清理,扩容时还会继续检查 -
调用
get()
方法时,没有直接命中、向后环形查找时会进行清理 -
调用
remove()
时,除了清理当前Entry,还会向后继续清理
5.Java中的四种引用
引用关系的强弱关系: 强引用 > 软引用 > 弱引用 > 虚引用
-
强引用
如果一个对象具有强引用,它就不会被垃圾回收器回收。即使当前内存空间不足,JVM也不会回收它,而是抛出OutOfMemoryError
错误,使程序异常终止。如果想中断强引用和某个对象之间的关联,可以显式地将引用赋值为null
,这样一来的话,JVM在合适的时间就会回收该对象 -
软引用
在使用软引用时,如果内存的空间足够,软引用就能继续被使用,而不会被垃圾回收器回收,只有在内存不足时,软引用才会被垃圾回收器回收。(软引用可用来实现内存敏感的高速缓存,比如网页缓存、图片缓存等。使用软引用能防止内存泄露,增强程序的健壮性) -
弱引用
具有弱引用的对象拥有的生命周期更短暂。当 JVM 进行垃圾回收,一旦发现弱引用对象,无论当前内存空间是否充足,都会将弱引用回收。 -
虚引用
虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。
注意点:
虚引用必须和引用队列(ReferenceQueue
)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之关联的引用队列中。(其它引用是被JVM回收后才被加入ReferenceQueue
中的。由于这个机制,所以虚引用大多被用于引用销毁前的处理工作。可以使用在对象销毁前的一些操作,比如说资源释放等。)
参考文章:
1.https://pdai.tech/md/java/thread/java-thread-x-threadlocal.html
2.https://blog.csdn.net/u010445301/article/details/111322569
3.https://blog.csdn.net/weixin_51626435/article/details/123681994