总记得在面试的时候被问到过,今天终于轮到你了ThreadLocal,从表面上读英文的意思为线程本地变量,这样也许更好理解了,就是每个线程自己独有的,不与其它线程共享的变量呗。
首先翻开源码,这个author的名字真的熟悉,对,就是dog李(Doug Lea),貌似lang包下的很多都是由这位哥编写的,看一下这个类中的结构(JDK1.8)
常用的就这几个,俩内部类,四个方法。
1. get()方法是用来获取ThreadLocal在当前线程中保存的变量副本。
2. set()用来设置当前线程中变量的副本。
3. remove()用来移除当前线程中变量的副本。
4. initialValue()是一个protected方法,一般是用来在使用时进行重写的,它是一个延迟加载方法。ThreadLocal没有被当前线程赋值时或当前线程刚调用remove方法后调用get方法,返回此方法值。
举个例子:
解释一下:
定义两个不同任务的线程,分别向各自的本地变量中存放值,见证两个线程本地变量中的内容是互不干扰的。
public class MyThreadLocal {
// 采用匿名内部类的方式来重写initialValue方法
private static final ThreadLocal<Object> threadLocal = new ThreadLocal<Object>() {
/**
* ThreadLocal没有被当前线程赋值时或当前线程刚调用remove方法后调用get方法,返回此方法值
*/
@Override
protected Object initialValue() {
System.out.println("调用get方法时,当前线程共享变量没有设置,调用initialValue获取默认值!");
return null;
}
};
// 操纵int类型的任务线程
public static class MyIntegerTask implements Runnable {
private String name;
MyIntegerTask(String name) {
this.name = name;
}
public void run() {
for (int i = 0; i < 5; i++) {
// ThreadLocal.get方法获取线程变量
if (null == MyThreadLocal.threadLocal.get()) {
// ThreadLocal.et方法设置线程变量
MyThreadLocal.threadLocal.set(0);
System.out.println("线程" + name + ": 0");
} else {
int num = (Integer) MyThreadLocal.threadLocal.get();
MyThreadLocal.threadLocal.set(num + 1);
System.out.println("线程" + name + ": " + MyThreadLocal.threadLocal.get());
if (i == 3) {
MyThreadLocal.threadLocal.remove();
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
// 操纵string类型的任务线程
public static class MyStringTask implements Runnable {
private String name;
MyStringTask(String name) {
this.name = name;
}
public void run() {
for (int i = 0; i < 5; i++) {
if (null == MyThreadLocal.threadLocal.get()) {
MyThreadLocal.threadLocal.set("a");
System.out.println("线程" + name + ": a");
} else {
String str = (String) MyThreadLocal.threadLocal.get();
MyThreadLocal.threadLocal.set(str + "a");
System.out.println("线程" + name + ": " + MyThreadLocal.threadLocal.get());
}
try {
Thread.sleep(800);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
new Thread(new MyIntegerTask("IntegerTask1")).start();
new Thread(new MyStringTask("StringTask1")).start();
}
}
调用get方法时,当前线程共享变量没有设置,调用initialValue获取默认值!
线程IntegerTask1: 0
调用get方法时,当前线程共享变量没有设置,调用initialValue获取默认值!
线程StringTask1: a
线程StringTask1: aa
线程IntegerTask1: 1
线程StringTask1: aaa
线程IntegerTask1: 2
线程StringTask1: aaaa
线程IntegerTask1: 3
线程StringTask1: aaaaa
调用get方法时,当前线程共享变量没有设置,调用initialValue获取默认值!
线程IntegerTask1: 0
一。首先看get方法:
涉及到的全部源码:
get();方法:供ThreadLocal对象来调用
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
getMap();方法:这个方法是返回当前线程t中的一个成员变量threadLocals,它是Thread类中的一个内部类
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocalMap getMap(Thread t) { return t.threadLocals; }
看一下ThreadLocalMap的实现:可以看到ThreadLocalMap的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;
}
}
。。。。。。。。。
}
getEntry();方法
private Entry getEntry(ThreadLocal<?> key) {
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);
}
setInitialValue();方法:就是如果map不为空,就设置键值对,为空,再创建Map。
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
createMap();方法:如果map为空,就初始化ThreadLocalMap,哈哈
void createMap(Thread t, T firstValue) { t.threadLocals = new ThreadLocalMap(this, firstValue); }
不难看出,get()方法,首先获取当前的线程,然后通过getMap(t)方法获取到一个map,map的类型为ThreadLocalMap。然后接着下面获取到<key,value>键值对,如果获取成功,则返回value值,如果map为空,则调用setInitialValue方法返回value。
测试完上面的例子,看完get方法的实现,应该明白ThreadLocal是怎么个原理了,大致如下(就是这样的):首先,在每个线程Thread内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals,这个threadLocals就是用来存储实际的变量的,键值为当前ThreadLocal变量,value为变量(比如说上面定义的String变量或者Integer变量)。初始时,在Thread里面,threadLocals为空,当通过ThreadLocal变量调用get()方法或者set()方法,就会对Thread类中的threadLocals进行初始化,并且以当前ThreadLocal变量为键值,以ThreadLocal要保存的变量为value,存到threadLocals。如果要使用副本变量,就可以通过get方法在threadLocals里面查找。
这种存储结构的好处:
1、线程死去的时候,线程共享变量ThreadLocalMap则销毁。
2、ThreadLocalMap<ThreadLocal,Object>键值对数量为ThreadLocal的数量,一般来说ThreadLocal数量很少,相比在ThreadLocal中用Map<Thread, Object>键值对存储线程共享变量(Thread数量一般来说比ThreadLocal数量多),性能提高很多。
二。ThreadLocal的应用场景:
最常见的ThreadLocal使用场景为 用来解决 数据库连接、Session管理等。
比如:代码来自:http://www.iteye.com/topic/103804
private static final ThreadLocal threadSession = new ThreadLocal();
public static Session getSession() throws InfrastructureException {
Session s = (Session) threadSession.get();
try {
if (s == null) {
s = getSessionFactory().openSession();
threadSession.set(s);
}
} catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
return s;
}
三。关于ThreadLocal导致的内存泄漏问题,和解决办法
当线程没有结束,但是ThreadLocal已经被回收,则可能导致线程中存在ThreadLocalMap<null, Object>的键值对,造成内存泄露。(ThreadLocal被回收,ThreadLocal关联的线程共享变量还存在)。
虽然ThreadLocal的get,set方法可以清除ThreadLocalMap中key为null的value,但是get,set方法在内存泄露后并不会必然调用,所以为了防止此类情况的出现,我们有两种手段。
1、使用完线程共享变量后,显示调用ThreadLocalMap.remove方法清除线程共享变量;
2、JDK建议ThreadLocal定义为private static,这样ThreadLocal的弱引用问题则不存在了。
四。关于什么是强引用什么是弱引用,以及解决OOM问题,dump文件的,后面会学习。