1.概述
维持线程封闭性除了Ad-hoc封闭和栈封闭,更规范的方法是使用ThreadLocal,这个类是java lang包下的一个类。他能使线程中的某个值与保存值的对象关联起来。ThreadLocal提供了get set等访问接口或方法,这些方法为每个使用该变量的线程都存有一份独立地副本,因此get总能返回由当前执行线程在调用set时设置的最新值。
2.属性
private final int threadLocalHashCode = nextHashCode(); //ThreadLocal实例hash值,用来区分不同实例
private static AtomicInteger nextHashCode =
new AtomicInteger();//可以看作hash值的一个基值
private static final int HASH_INCREMENT = 0x61c88647;//hash值每次增加量
3.内部类 ThreadLocalMap
用于保存线程中的变量使用一个Enrty类型的数组 private Entry[] table;
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
Entry结构如上,并且是一个弱引用的对象。是因为当ThreadLocal指向null的时候,会出现key为空的Entry,对应的value是无法访问到的。便存在着内存泄漏的问题。所以将Enrty设置成弱引用可以避免内存泄漏的问题,这些对象只能存活到下一次垃圾回收之前。
3.1属性
private static final int INITIAL_CAPACITY = 16;//数组初始容量
private Entry[] table;//用于保存变量的数组
private int size = 0;//数组中变量的个数
private int threshold; // 阈值
3.2构造方法
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {//key value
table = new Entry[INITIAL_CAPACITY];//根据初始容量构建一个Entry数组
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);//计算存储的位置
table[i] = new Entry(firstKey, firstValue);//构建一个保存value的Enrty
size = 1;//当前数组内元素个数1个
setThreshold(INITIAL_CAPACITY);//设置阈值为16
}
private ThreadLocalMap(ThreadLocalMap parentMap) {//构建一个新的ThreadLocalMap,继承自参数parenytMap
Entry[] parentTable = parentMap.table;
int len = parentTable.length;
setThreshold(len);
table = new Entry[len];
for (int j = 0; j < len; j++) {
Entry e = parentTable[j];
if (e != null) {
@SuppressWarnings("unchecked")
ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
if (key != null) {
Object value = key.childValue(e.value);
Entry c = new Entry(key, value);
int h = key.threadLocalHashCode & (len - 1);
while (table[h] != null)
h = nextIndex(h, len);
table[h] = c;
size++;
}
}
}
}
3.3方法
private void setThreshold(int len) {//设置阈值
threshold = len * 2 / 3;
}
/**
* Increment i modulo len.
*/
private static int nextIndex(int i, int len) {//下一个索引
return ((i + 1 < len) ? i + 1 : 0);
}
/**
* Decrement i modulo len.
*/
private static int prevIndex(int i, int len) {//前一个索引
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
private Entry getEntry(ThreadLocal<?> key) {//根据key获得Entry,根据传入的key计算hash然后得到数组中的位置。找到了返回,没找到就继续往后找
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
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;
while (e != null) {
ThreadLocal<?> k = e.get();
if (k == key)//当e对应的ThreadLocal和传入的参数key一样的时候返回Enrty
return e;
if (k == null)//若e指向的ThreadLocal为空,则将这个Entry对象清空
expungeStaleEntry(i);
else//若e指向的ThreadLocal与传入的参数不同,则获取i下一位对应的Entry
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
private void set(ThreadLocal<?> key, Object value) {//添加到数组中
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
//先寻找有没有已存在的key对应的元素
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
if (k == key) {
e.value = value;
return;
}
if (k == null) {
replaceStaleEntry(key, value, i);//替换
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
private void remove(ThreadLocal<?> key) {//移除key对应的Entry
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;
}
}
}
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// expunge entry at staleSlot
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// Rehash until we encounter null
Entry e;
int i;
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
tab[i] = null;
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
4.set方法
public void set(T value) {
Thread t = Thread.currentThread();//获取当前的线程
ThreadLocalMap map = getMap(t);//根据当前的线程得到ThreadLocalMap
if (map != null)//若不为空
map.set(this, value);//则将ThreadLocal作为key,value作为value保存在map中
else
createMap(t, value);//否则新建一个Map
}
5.get方法
public T get() {
Thread t = Thread.currentThread//获取当前线程
ThreadLocalMap map = getMap(t);//获取当前线程的ThradLocalMap对象
if (map != null) {//若不为空
ThreadLocalMap.Entry e = map.getEntry(this);//从中获取key
if (e != null) {//key不为空
@SuppressWarnings("unchecked")
T result = (T)e.value;//获得值
return result;
}
}
return setInitialValue();
}
6.remove方法
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
7.应用场景
- 框架中的应用。Spring采用ThreadLocal的方式,来保证单个线程中的数据库操作使用的是同一个数据库连接。
- 实际工作中的应用。我们知道SimpleDataFormat不是线程安全的。所以如果声明为全局变量会有并发安全隐患。一般会在使用这个类的方法里创建SimpleDataFormat对象,这样不会有并发隐患。但是方法内部的对象在方法执行完其生命周期就结束了,如果一个请求在调用链路的n个方法中都调用了SimpleDataFormat,是不是要创建n个对象?此时我们可以将其声明为ThreadLocal,一个线程在其生命周期内使用同一个SimpleDataFormat,不同对象之间使用各自的SimpleDataFormat对象,形成线程间的数据隔离,不会有并发安全隐患。然而这种场景,适用于一个线程有多个方法调用都用到了SimpleDataFormat,可以减少创建对象的次数。如果生命周期内只有一个方法使用了这个对象,在方法里创建就好了。
- 用于传递参数。项目中,一个线程横跨若干个方法调用,需要传递的对象,也就是上下文,它是一种状态,经常就是用户身份、任务信息等,就会存在过渡传参的问题。在线程最开始设置ThreadLocal对象,在线程生命周期的多个方法执行过程中,通过tl.get()就可以取出参数。这种方法可以避免通过方法入参传递变量。
8.内存泄漏问题
1.每次使用完ThreadLocal将tl设置为null 这样ThreadLocal只存在弱引用,下一次gc的时候就会将其回收掉。
2.当ThreadLocal对象被回收后,key指向的就是null 此时无法访问到对应的value,这就造成了内存泄漏的问题。所以需要显示的删除这个键值对。调用tl.remore()。