背景:
并发处理很多时候可以提高处理的速度,但是如果是对共享变量操作时,也会带来一些问题(导致无法满足可见性,有序性,原子性),处理这些问题,第一种常见的方法是加锁,第二种常见的方法是通过CAS(保证标记变量操作的原子性) + Volitle(可见性),第三种常见的处理方法让每个线程都有自己单独的一份,例如ThreadLocal的使用。
使用示例:
public class Test {
public static class MyRunnable implements Runnable {
private ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
@Override
public void run() {
threadLocal.set((int) (Math.random() * 100D));
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println(threadLocal.get());
}
}
public static void main(String[] args) {
MyRunnable sharedRunnableInstance = new MyRunnable();
Thread thread1 = new Thread(sharedRunnableInstance);
Thread thread2 = new Thread(sharedRunnableInstance);
thread1.start();
thread2.start();
}
}
输出:
63
82
Thread、ThreadLocal、ThreadLocalMap、Entry之间的关系:
简述:一个Thread中只有一个ThreadLocalMap,一个ThreadLocalMap值有一个Entry类型的数组(数组被初始化后默认大小为16),set操作本质就是将ThreadLocal对象为键,value为值封装成Entry对象存入ThreadLocalMap中的数组中。而get操作就是以ThreadLocal对象为键找到ThreadLocalMap中Entry数组的索引,然后返回ThreadLocal对象对应的value值。无论是set(存入)还是get(获取)都要根据key(ThreadLocal对象)找到Entry数组的下标,在这里采用的是开放定址法,而HashMap中使用的拉链法。
ThreadLocal各类引用关系图:
1)疑惑:设置ThreadLocal设置为强引用,那么在将ThreadLocalRef设置为空后,ThreadLocal对象并不会被回收,会导致内存泄漏。如果ThreadLocal是弱引用,此时将ThreadLocalRef设置为空,此后出发GC后,ThreadLocal对象会被回收,但是此时Entry中的value值依旧无法回收,依然导致了内存泄漏。所以每次使用ThreadLocal过后会调用remove方法并将ThreadLocalRef设置为空,此时即使ThreadLocal是强引用,ThreadLocal对象和Entry对象都会被回收,那为啥还要将ThreadLocal设置为弱引用呢。
2)思考:ThreadLocalMap没有提供Api给我们调用,如果提供了调用方法,就可以直接使用字符串作为Entry的key了,我感觉那样也很方便。
这里使用ThrealLocal实例作为Map的Key,但实际上,它并不真的持有ThreadLocal的引用,而是弱引用,而当ThreadLocal的外部强引用被收回后,在垃圾回收时,弱引用会被回收,但value值依然存在,如果后面有set,get方法时,对应的value值会被清除,或当线程执行完后,整个map对象会被回收(Entry数组是Map的成员属性)。假设线程没有被销毁,且后面没有set和get操作,那么此时就会导致内存泄漏。
源码:
类Thread:
class Thread{
ThreadLocal.ThreadLocalMap threadLocals = null; //有一个ThreadLocalMap属性
.......
}
创建的线程里都有一个threadLocal对象。
类ThreadLocal:
class ThreadLocal{
//ThreadLocalMap类
static class ThreadLocalMap{
private static final int INITIAL_CAPACITY = 16; //默认数组大小为16
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY]; //Entry数组初始大小为16
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue); //Entry对象放入数组中
size = 1;
setThreshold(INITIAL_CAPACITY);
}
static class Entry extends WeakReference<ThreadLocal<?>> {
.....
}
//用来存储Entry对象的数组
private Entry[] table;
//以当前ThreadLocal对象为键,设置value值到Entry对象中
public void set(T value){
.......
}
//获取value值
public T get(){
.......
}
}
}
set()方法:
set()方法源码:
public void set(T value) {
Thread t = Thread.currentThread(); //首先获取当前线程对象
ThreadLocalMap map = getMap(t); //通过getMap(t)拿到xianc
if (map != null)
map.set(this, value); //key是ThreadLocal当前对象,value是我们设置的值
else
createMap(t, value); //如果map没有初始化,就先初始化t.threadLocals
}
在set时,首先获得当前线程对象,然后通过getMap()拿到线程的ThreadLocalMap,并将值设置到ThreadLocalMap中。map现在简单理解成是Map,存入以ThreadLocal对象为键,value为值的键值对。如果map为null(没有初始化)就初始化t.threadLocals,详细的说明如下:
getMap函数
ThreadLocalMap getMap(Thread t) {
return t.threadLocals; //threadLocals是类Thread的属性
}
getMap返回Thread实例的threadLoclas属性赋值给map。Thread中ThreadLocalMap类型的属性ThreadLocals声明如下:
class Thread implements Runnable{ //threadLocals是Thread类中的属性
ThreadLocal.ThreadLocalMap threadLocals = null;
}
如果map为空,就执行createMap函数,createMap函数的定义如下:
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue); //key是当前ThreadLocal对象
}
ThreadLocalMap的构造函数的源码:
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY]; //默认初始容量为16
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue); //Entry对象存入数组
size = 1; //Entry对象的数量为1
setThreshold(INITIAL_CAPACITY);
}
如果map不为空,也就是threadLocals属性已经被初始化过了,就直接使用set方法赋新值:
map.set(this,value);
set方法的源码:
/**
* Set the value associated with key.
*
* @param key the thread local object
* @param value the value to be set
*/
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; //table是ThreadLocalMap中的属性
int len = tab.length;
int i = key.threadLocalHashCode & (len-1); //通过key的hashCode来计算索引的位置i
//不同于HashMap,HashMap中使用的是拉链法,这里使用的是开放地址法
for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) { //取出索引为i处的值,如果不为空,就将索引向后移动一格,直到找到空的位置
ThreadLocal k = e.get(); //获取键值
if (k == key) { //如果key(ThreadLocal)的值相同,那么就将value值替换,然后直接返回
e.value = value;
return;
}
if (k == null) { //数组i出的Entry不为空,但是Entry的key(ThreadLocal)为空
replaceStaleEntry(key, value, i); //此时直接将值放在数组的该位置
return;
}
}
tab[i] = new Entry(key, value); //如果找到索引i处,数组为空,就赋新值
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold) //判断当前存储的对象个数是否已经超过了阈值
rehash(); //如果超过了阈值,就要进行扩容并将所有的对象重新计算位置
}
关于set方法的简要说明:首先第17行代码根据key值得到数组中索引的位置 i ,使用开放定址法,从索引处开始判断该处是不是为空(没有Entry对象),如果该位置有Entry对象,此时会进一步判断,如果该Entry对象的key值与新插入的Entry对象的key值相同,那么就直接将原先对象的value值替换成新的value值。如果该Entry对象的key为空,此时就执行第27行代码(出现Entry对象不为空,而key为空,是因为执行key的引用为弱引用,每次GC都会被回收),此时执行第27行代码。在从索引 i 处向后挪动的过程中,如果遇到数组某个下标出没有Entry对象,此时就直接执行32行,将新的Entry对象存入该处。在第34行会判断数组中存储的Entry对象的个数是否已经超过了阈值的大小,如果超过了,需要重新扩充并将所有的对象重新计算位置(rehash函数实现)。
ThreadLocalMap中存储的是Entry对象本质上是一个弱引用WeakReference<ThreadLocal>,也就是说ThreadLocal里面存储的对象本质是一个ThreadLocal对象的弱引用,该ThreadLocal随时可能倍被回收(弱引用每次GC后,都会回收),即导致ThreadLocalMap里面对应的Value的Key是null,我们使用expungeStateEntries函数来清理掉这些key为空的Entry对象。
这里注意:阈值threshold等于table数组长度的2/3,而扩容的条件是数组中Entry对象的个数超过了阈值的3/4。
private void rehash() {
expungeStaleEntries(); //将key为null的Entry对象清除
// Use lower threshold for doubling to avoid hysteresis
if (size >= threshold - threshold / 4) //当大小大于阈值的四分之三时,就扩容
resize();
}
resize()扩容函数
private void resize() {
Entry[] oldTab = table;
int oldLen = oldTab.length;
int newLen = oldLen * 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(); //获取key
if (k == null) { //如果为空,就将value值也设置为空
e.value = null; // Help the GC
} else { //如果不为空
int h = k.threadLocalHashCode & (newLen - 1); //重新根据hash值计算索引值
while (newTab[h] != null) //如果冲突,往后移一步,直到遇到空格
h = nextIndex(h, newLen);
newTab[h] = e; //将Entry对象放入
count++;
}
}
}
setThreshold(newLen); //设置阈值
size = count;
table = newTab;
}
get()方法
public T get() {
Thread t = Thread.currentThread(); //获取当前线程
ThreadLocalMap map = getMap(t); //获取当前线程中的ThreadLocalMap
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this); //通过key(当前的LocalThread)获取value值
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
get()方法获取当前线程的ThreadLocalMap类型的对象threadLoacals赋值给map,如果map不为空,就以ThreadLocal对象是键找到对应的Entry对象,如果Entry对象不为空,就返回Entry对象的value值。如果map为空就执行setInitialValue()
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);//根据hash值得到索引
Entry e = table[i]; //取出索引处的Entry对象
if (e != null && e.get() == key) //如果Entry对象不为空并且Entry对象的键值等于key说明找到了
return e;
else
return getEntryAfterMiss(key, i, e);//否则执行这个函数
}
根据哈希值找到索引,如果对应的Entry对象不为空,且Entry对象的key不为空,就返回Entry对象。否则执行第7行的函数
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {//如果Entry对象为空,或者Entry对象的键与key不相等
Entry[] tab = table;
int len = tab.length;
while (e != null) {
ThreadLocal<?> k = e.get();
if (k == key)
return e;
if (k == null)
expungeStaleEntry(i); //键为空,就清理对应的value值
else
i = nextIndex(i, len); //移到数组下一个位置
e = tab[i];
}
return null; //如果Entry对象为空,直接返回null
}
该函数主要是对Entry对象为空和Entry对象的key值为空做了处理,如果Entry对象为空,表明通过无法取到这个值,直接返回null,如果Entry对象的key为空,就将该Entry对象的value值清空,然后返回null,否则就在就在数组中移动一位重复上面的判断,直到找到Entry对象的键值等于key返回value值。
参考:
再有人问你什么是ThreadLocal,就把这篇文章甩给他!
再有人问你什么是ThreadLocal,就把这篇文章甩给他!
LocalThread基本用法讲解:
http://ifeve.com/java-threadlocal%E7%9A%84%E4%BD%BF%E7%94%A8/
原理讲的比较好的
https://blog.csdn.net/huachao1001/article/details/51734973
https://blog.csdn.net/huachao1001/article/details/51970237
ThreadLocal的内存泄漏
https://blog.csdn.net/xlgen157387/article/details/78513735
https://www.cnblogs.com/onlywujun/p/3524675.html