ThreadLock
不同的线程,可以使用同一个ThreadLocal,同一个线程需要使用不同的ThreadLoca
简单使用
static final ThreadLocal sThreadLocal = new ThreadLocal();
sThreadLocal.set()
sThreadLocal.get()
threadlocal的作用负责访问和维护ThreadLocalMap.
ThreadLocalMap是每一个线程内部用于存储数据的地方。
set()方法就是把Threadlocal插入当前Thread维护的ThreadLocalMap中,如果你在线程1里面去set(),那么你在线程2里面去获取的时候,它取得是线程2的ThreadLocalMap,但是线程2里面的ThreadLocalMap并没有插入ThreadLocal.
我们看一下Thread类中的一个成员变量
public class Thread implements Runnable {
ThreadLocal.ThreadLocalMap threadLocals = null;
}
实际上ThreadLocal会获取当前线程的threadLocals,如果值为null,就实例化,如果值不为null,就在threadLocalMap中进行设置值。保证了值设置到对应的线程中。
我们看一下ThreadLocal源码
//set 方法
public void set(T value) {
//获取当前线程
Thread t = Thread.currentThread();
//实际存储的数据结构类型
ThreadLocalMap map = getMap(t);
//如果存在map就直接set,没有则创建map并set
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
//getMap方法
ThreadLocalMap getMap(Thread t) {
//thred中维护了一个ThreadLocalMap
return t.threadLocals;
}
//createMap
void createMap(Thread t, T firstValue) {
//实例化一个新的ThreadLocalMap,并赋值给线程的成员变量threadLocals
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
threadLocalMap是一个类,threadLocalMap维护了一个Entry[] table,每一个数组元素是一个entity(保存threadLocal,value等),我们使用threadLocal.set(value),只能set一次,那为什么我们不使用entity,要使用数组呢?
1、首先这个线程不光光你的代码要用来存放value,其他框架spring也要用这个线程存放value,如果threadLocalMap只用entity对象存储,你进行set值的时候,就会把spring设置的值给覆盖掉。所以线程使用数组来存放各个框架设置的value。
2、不同框架使用自己的ThreadLocal,利用ThreadLocal将value存放到线程ThreadLocalMap中的不同的位置。原理:利用 int i = threadLocal.threadLocalHashCode&(len-1),i就是数组对应的位置。
我们不同的框架都可以利用线程存放自己的value,相互不影响
查看threadLocal.threadLocalHashCode返回的值
同一个threadLocal使用threadLocalHashCode值返回的都是同一个值,不同的ThreadLocal使用的threadLocalHashCode值不同,因为new ThreadLocal()的时候,已经将threadLocalHashCode自增了。所以不同的框架都new ThreadLocal(),生成的table索引就不一样,就可以存放到threadLocalMap不同的位置上了。
一个线程有很多ThreadLocal,不同的框架就可以用不同的的ThreadLocal保存数据。
//设置不可以变threadLocalHashCode,防止代码对它进行修改,属性调用方法只调用一次,调用的值进行赋值;
private int threadLocalHashCode = nextHashCode();
private static int nextHashCode() {
//自增1
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
//static让所有的框架公用一个nextHashCode;不同的框架使用这个值,都会将他加自增1
private static AtomicInteger nextHashCode = new AtomicInteger();
private static final int HASH_INCREMENT = 0x61c88647;
ThreadLocalMap为什么要定义在ThreadLocal中(静态内部类),而不直接定义在Thread中?
将ThreadLocalMap定义在Thread类内部看起来更符合逻辑,但是ThreadLocalMap并不需要Thread对象来操作,所以定义在Thread类内只会增加一些不必要的开销。定义在ThreadLocal类中的原因是ThreadLocal类负责ThreadLocalMap的创建,仅当线程中设置第一个ThreadLocal时,才为当前线程创建ThreadLocalMap,之后所有其他ThreadLocal变量将使用一个ThreadLocalMap。
总的来说就是,ThreadLocalMap不是必需品,定义在Thread中增加了成本,定义在ThreadLocal中按需创建。
ThreadLock引发内存泄漏的问题
内存泄漏
指由于对象永远无法被垃圾回收导致其占用的JVM内存无法被释放。持续的内存泄漏会导致JVM可用内存减少,并最终可能导致JVM内存溢出(out of memory)直到JVM宕机。
每个thread中都存在一个map, map的类型是ThreadLocal.ThreadLocalMap. Map中的key为一个threadlocal实例. 这个Map的确使用了弱引用,不过弱引用只是针对key. 每个key都弱引用指向threadlocal. 当把threadlocal实例置为null以后,没有任何强引用指向threadlocal实例,所以threadlocal将会被gc回收. 但是,我们的value却不能回收,因为存在一条从current thread连接过来的强引用. 只有当前thread结束以后, current thread就不会存在栈中,强引用断开, Current Thread, Map, value将全部被GC回收.
所以得出一个结论就是只要这个线程对象被gc回收,就不会出现内存泄露,但在threadLocal设为null和线程结束这段时间不会被回收的,就发生了我们认为的内存泄露。其实这是一个对概念理解的不一致,也没什么好争论的。最要命的是线程对象不被回收的情况,这就发生了真正意义上的内存泄露。比如使用线程池的时候,线程结束是不会销毁的,会再次使用的。就可能出现内存泄露。
PS.Java为了最小化减少内存泄露的可能性和影响,在ThreadLocal的get,set的时候都会清除线程Map里所有key为null的value。所以最怕的情况就是,threadLocal对象设null了,开始发生“内存泄露”,然后使用线程池,这个线程结束,线程放回线程池中不销毁,这个线程一直不被使用,或者分配使用了又不再调用get,set方法,那么这个期间就会发生真正的内存泄露。
由于ThreadLocalMap生命周期和Thread一样长,ThreadLocalMap中table中的entity由不同的ThreaLocal创建,如果ThreadLocal为null,但是entity中的值包括entity无法被回收,发内存泄漏。
解决方式:
调用threadlocal的remove方法.
threadlocal.set(T value)和get(T value)
set源码
private void set(ThreadLocal key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
#遍历table直到table[i]为空。
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal k = e.get();
#table[i].key是当前threadlocal,更新value,return;
if (k == key) {
e.value = value;
return;
}
#table[i].key如果是空,重新设置值,return;
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
#如果table[i]为空,正常设置值。
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
get源码
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
#如果获取不到,会设置一个空值,并返回
return setInitialValue();
}
private Entry getEntry(ThreadLocal key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
#如果table[i].key等于当前key,返回
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}
private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
往后一直遍历,找到table[i].key等于当前的key
while (e != null) {
ThreadLocal k = e.get();
if (k == key)
return e;
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}