ThreadLocal作用是让 每一个线程都独有一份空间来存储自己需要的变量,这份变量 对其它线程不可见!
因为之前 线程都是共享进程的资源嘛,如果要 线程独有自己的资源就需要ThreadLocal,并且这个变量生命周期和线程生命周期一样。
案例
public class MyDemo {
private static ThreadLocal<String> tl = new ThreadLocal<>();
//一个类型可以理解为,如果要存储多个变量,则需要定义多个这个
private String content;
private String getContent() {
return tl.get();
}
private void setContent(String content) {
tl.set(content);
}
public static void main(String[] args) {
MyDemo demo = new MyDemo();
for (int i = 0; i < 5; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
demo.setContent(Thread.currentThread().getName() + "的数据");
System.out.println("-----------------------");
System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());
}
});
thread.setName("线程" + i);
thread.start();
}
}
}
使用场景
- 每个线程需要一个独享的对象,例如JDBC的Connection,如果不隔离,多个线程共用一个连接,可能会导致B线程提交了A线程不应该提交的事务,或回滚了本来应该提交的事务。(加锁也可,但是非常影响性能)。还有Mybatis的分页场景,Spring的事务管理。
- 当前用户信息需要被线程内所有方法共享,即减少变量作为参数传递的复杂度
强,软,弱,虚引用(看源码会用到)
- 强引用
Object obj = new Object();中的obj就是强引用,通过关键字new创建的普通对象都是强引用
只要强引用指向一个对象,就能表明对象还存在,垃圾收集器就不会碰这种对象
对于一个普通的对象,如果没有其他的引用关系,或者显示的将强引用赋值为null,就可以被垃圾回收收集了 - 软引用(SoftReference)
软引用生命周期比强引用短一些
当JVM认为内存不足时,会去试图回收软引用指向对象
如果JVM认为内存空闲,会暂时保留软引用(可用于缓存场景) - 弱引用(WeakReference)
弱引用的生命周期比软引用更短,在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了具有弱引用的对象,无论当前内存空间是否不足,都会回收它的内存
ThreadLocalMap里面的Entry就是弱引用
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
- 幻象引用(虚引用)(PhantomReference)
幻象引用用是最弱的一种引用关系,如果一个对象仅持有虚引用,那么它就和没有任何引用一样,它随时可能会被回收,它只有一个构造函数和一个 get() 方法,而且它的 get() 方法仅仅是返回一个null,也就是说将永远无法通过虚引用来获取对象,虚引用必须要和 ReferenceQueue 引用队列一起使用(专门用来管理堆外内存)
弱引用案例
public class ReferenceExample {
static Object object=new Object();
public static void main(String[] args) {
// Object strongRef=object; //强引用
// SoftReference<Object> softReference=new SoftReference<>(object);//软引用
WeakReference<Object> objectWeakReference=new WeakReference<>(object);//弱引用
object=null;
System.gc();
System.out.println(objectWeakReference.get());
// System.out.println(softReference.get());
}
}
输出结果为空
内部结构
每个Thread维护一个ThreadLocalMap,这个Map的key是ThreadLocal实例本身(公共变量,即上面的tl),value才是真正要存储的值Object。
- 每个Thread线程内部都有一个Map (ThreadLocalMap)
- Map里面存储ThreadLocal对象(key)和线程的变量副本(value)
- Thread内部的Map是由ThreadLocal维护的,由ThreadLocal负责向map获取和设置线程的变量值。
- 对于不同的线程,每次获取副本值时,别的线程并不能获取到当前线程的副本值,形成了副本的隔离,互不干扰。
设计的好处
这个设计与早期的设计刚好相反,早期设计每个ThreadLocal都创建一个Map,然后用线程作为Map的key,要存储的局部变量作为Map的value。
现在的设计有如下两个优势:
- 这样设计之后每个Map存储的Entry数量就会变少。因为之前的存储数量由Thread的数量决定,现在是由ThreadLocal的数量决定。在实际运用当中,往往ThreadLocal的数量要少于Thread的数量。(键越少,冲突越少)
- 当Thread销毁之后,对应的ThreadLocalMap也会随之销毁,能减少内存的使用。(直接销毁整个Map,如果是原来的设计,线程结束后,如果是采用线性探测,还不敢删除Map里面对应的键值)
主要方法
由上图可知
- set()
在当前线程的ThreadLocalMap内,设置一个值存储到里面中,这个值的表现形式是entry对象(key,value形式)key是ThreadLocal实例本身(公共变量,即上面的tl),值是value。有点绕画图理解比较好
相当于在当前线程范围内建立了副本。 - get()
从当前线程的ThreadLocalMap内取出当前ThreadLocal类型的值. - remove()
从当前线程的ThreadLocalMap内移除当前ThreadLocal类型的值. - withInitial
java8中的初始化方法
源码(一定要把内部结构看懂再看)
set方法
public void set(T value) {
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 判断map是否存在
if (map != null)
// 存在则调用map.set设置此实体entry,传递this,就是传递key即这种类型的ThreadLocal
map.set(this, value);
else
// 1)当前线程Thread 不存在ThreadLocalMap对象
// 2)则调用createMap进行ThreadLocalMap对象的初始化
// 3)并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
createMap(t, value);
}
/**
* 获取当前线程Thread对应维护的ThreadLocalMap
*
* @param t the current thread 当前线程
* @return the map 对应维护的ThreadLocalMap
*/
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;//这个threadLocals就是当前线程的ThreadLocalMap
}
/**
*创建当前线程Thread对应维护的ThreadLocalMap
*
* @param t 当前线程
* @param firstValue 存放到map中第一个entry的值
*/
void createMap(Thread t, T firstValue) {
//这里的this是调用此方法的threadLocal,创建好以后赋值给线程的ThreadLocalMap的引用指针即threadLocals
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
/**
createMap调用构造方法,真正创建,并且赋值
*/
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];//默认长度为16的数组
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);//计算当前数组下标
table[i] = new Entry(firstKey, firstValue);//把key/value存储到i的位置
size = 1;
setThreshold(INITIAL_CAPACITY);
}
/**
真正干事的set,即ThreadLocalMap的set,这里的set有第一次set和更改第一次set的两种情况
*/
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);//通过key计算数组下标
//e!=null说明是当前位置已经有人了,哈希冲突了或者就是想要的位置但是有原来的值
//采用线性探索,解决哈希冲突问题
for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)])
{
ThreadLocal<?> k = e.get();
// 就是想要的位置但已经存在了值, 就直接替换。
if (k == key) {
e.value = value;
return;
}
//此位置的key为空,说明ThreadLocal成员变量回收掉了,那么用新元素替换陈旧的元素
//这样相当于进行了垃圾清理动作,防止内存泄漏
if (k == null) {
replaceStaleEntry(key, value, i);//这个代码,见下面
return;
}
}
//如果当前位置没有,就是第一次设置,直接干就完了
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
get方法
/**
* 返回当前线程中保存ThreadLocal的值
* 如果当前线程没有此ThreadLocal变量,
* 则它会通过调用{@link #initialValue} 方法进行初始化值
*
* @return 返回当前线程对应此ThreadLocal的值
*/
public T get() {
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 如果此map存在
if (map != null) {
// 以当前的ThreadLocal 为 key,调用getEntry获取对应的存储实体e
ThreadLocalMap.Entry e = map.getEntry(this);
// 对e进行判空
if (e != null) {
@SuppressWarnings("unchecked")
// 获取存储实体 e 对应的 value值
// 即为我们想要的当前线程对应此ThreadLocal的值
T result = (T)e.value;
return result;
}
}
/*
初始化 : 有两种情况有执行当前代码
第一种情况: map不存在,表示此线程没有维护的ThreadLocalMap对象
第二种情况: map存在, 但是没有与当前ThreadLocal关联的entry
*/
//如果之前没有使用set,则可能通过withInitial这个方法这条线来进行初始化的
//可通过匿名内部类的方法完成初始化,也可继承ThreadLocal重写initialValue
//如果这个也不是,直接创建好Map再返回空
return setInitialValue();
}
/**
* 初始化
*
* @return the initial value 初始化后的值
*/
private T setInitialValue() {
// 调用initialValue获取初始化的值
// 此方法可以被子类重写, 如果不重写默认返回null
T value = initialValue();
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 判断map是否存在
if (map != null)
// 存在则调用map.set设置此实体entry
map.set(this, value);
else
// 1)当前线程Thread 不存在ThreadLocalMap对象
// 2)则调用createMap进行ThreadLocalMap对象的初始化
// 3)并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
createMap(t, value);
// 返回设置的值value
return value;
}
remove方法
/**
* 删除当前线程中保存的ThreadLocal对应的实体entry
*/
public void remove() {
// 获取当前线程对象中维护的ThreadLocalMap对象
ThreadLocalMap m = getMap(Thread.currentThread());
// 如果此map存在
if (m != null)
// 存在则调用map.remove
// 以当前ThreadLocal为key删除对应的实体entry
m.remove(this);
}
//真正干活的remove方法
private void remove(ThreadLocal<?> key) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
if (e.get() == key) {
e.clear();
expungeStaleEntry(i);
return;
}
}
}
内存泄漏
-
不考虑线程退出的情况下,如果不想用某个ThreadLocal对象了,正常应该是将它的引用置为空,但如果ThreadLocalMap里面的entry是强引用,就回收不了,因为始终有entry也作为强引用指向该ThreadLocal对象。所以entry应该使用弱引用。
-
但使用弱引用仍然可能出现内存泄漏,因为entry指向的ThreadLocal对象被回收了,value不能访问了,但数据还在!所以我们使用时应该养成好习惯,不再使用的时候调用remove()这样value也会移除掉,避免内存溢出。
-
此外还有一种危险是,如果线程是线程池的, 在线程执行完代码的时候并没有结束,只是归还给线程池,这个时候ThreadLocalMap 和里面的元素是不会回收掉的。所以记住线程池里面的线程执行完后,一定要清理掉threadlocals(即ThreadLocalMap ) !