我的原则:先会用再说,内部慢慢来。
学以致用,根据场景学源码
一、架构图
二、为什么会内存泄漏?
- 看下图,当 threadLocal1,threadLocal2,threadLocal3 = null的时候,table中 Entry的引用依然还在。假如thread01,thread02,一直不结束。那么Entry中的引用会一直存在(thread01Ref->Thread01->threadLocalMap01->entry->valueRef->valueMemory), 导致在垃圾回收的时候进行可达性分析的时候,value可达从而不会被回收掉,但是该value永远不能被访问到,这样就存在了内存泄漏。
=== 点击查看top目录 ===
三、ThreadLocal的Entry 为什么要用 weakReference ?
- ThreadLocal.ThreadLocalMap.Entry
public class ThreadLocal<T> {
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
}
}
- Thread
public java.lang.class Thread implements Runnable {
...
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
...
}
- Thread的 exit 方法
private void exit() {
if (group != null) {
group.threadTerminated(this);
group = null;
}
/* Aggressively null out all reference fields: see bug 4006245 */
target = null;
/* !!!看这里!!! */
threadLocals = null;
/* !!!看这里!!! */
inheritableThreadLocals = null;
inheritedAccessControlContext = null;
blocker = null;
uncaughtExceptionHandler = null;
}
Thread#exit方法会把内部的threadLocals设置为 null,threadLocalMap生命周期实际上thread的生命周期相同。
3.1 为什么ThreadLocal不用强引用?
- 因为weakReference 能够一定程度上避免内存泄漏
当Thread一直存在,threadLocal1,threadLocal2,threadLocal3 = null的时候。GC看到 threadLocal1,threadLocal2,threadLocal3 指向的对象的只有 weakReference 引用的时候,会将 threadLocal 指向对象的空间进行回收。
- 假如ThreadLocal2 = null。那么 GC 看到只有一个弱引用会进行回收。
- 如果是强引用的话,那么只能手动设置 table[1] = null 才能把这个对象回收。
=== 点击查看top目录 ===
四、ThreadLocal是如何减少内存泄漏的?
4.1. 泄漏在哪里?
看上图 === gc回收threadLocal2 ===,虽然weakReference的 threadLocal2占用的空间被回收了,但是Entry2(k=null,v=v2) 这个没用了,属于脏数据。但是没被回收,所以泄漏在这里。除非线程 thread 结束。
4.2 线程什么时候终结?
- 如果你是 new 一个的话,那么 run方法跑完的了,自然就会结束
- 在实际使用中我们都是会用线程池去维护我们的线程,比如在Executors.newFixedThreadPool()时创建线程的时候,为了复用线程是不会结束的。所以上面的 Entry2(k=null,v=v2) 就会一直存在,所以就泄漏了。
4.3. 源码如何解决?
在threadLocal的生命周期里(set,getEntry,remove)里,都会针对key为null的脏entry进行处理。每次调用都会去处理一下脏 Entry.
4.4 源码已经解决了,为什么依旧会泄漏?
因为你得调用4.3所说的那几个方法(set,getEntry,remove),如果你一直不去理他,不去调用,那么他自然在。这个解决方案很被动!!!
五、人工如何解决内存泄漏?
- 上述 4.4 是被动进行脏数据清理。那么我们开发时要养成良好习惯,对于 ThreadLocal 我们要进行手动释放。
5.1 如何进行手动释放?
-
每次使用完ThreadLocal,都调用它的remove()方法,清除数据。
-
ThreadLocal#remove 方法
public void ThreadLocal#remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
- ThreadLocal.ThreadLocalMap#remove 方法
private void ThreadLocal.ThreadLocalMap#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;
}
}
}
- Reference#clear() 方法
public void Reference#clear() {
this.referent = null;
}
5.2 demo 释放
//每个人都有一个账户,每次买东西都会进行扣费,每个人花的是自己的钱,每个人的账户存款都不一样。一个人就是一条线程,账户存款就是线程内的局部变量。
public class _22_TestThreadLocal {
public static void main(String[] args) {
wallet wallet = new wallet();
// 3. 3个线程共享wallet,各自消费
new Thread(new TaskDemo(wallet), "A").start();
new Thread(new TaskDemo(wallet), "B").start();
new Thread(new TaskDemo(wallet), "C").start();
}
private static class TaskDemo implements Runnable { //一个人就像一个线程
private wallet wallet;
public TaskDemo(wallet wallet) {
this.wallet = wallet;
}
public void run() {
try{
for (int i = 0; i < 3; i++) {
wallet.spendMoney();
// 4. 每个线程打出3个
System.out.println(Thread.currentThread().getName() + " --> balance["
+ wallet.getBalance() + "] ," + "cost [" + wallet.getCost() + "]");
}
}finally {
wallet.removeAll();
}
}
}
private static class wallet { //一个人就像一个线程
// 1.通过匿名内部类覆盖ThreadLocal的initialValue()方法,指定初始值
private static ThreadLocal<Integer> balance = ThreadLocal.withInitial(new Supplier<Integer>() {
@Override
public Integer get() {
return 100;
}
}); // 假设初始账户有100块钱
private static ThreadLocal<Integer> cost = ThreadLocal.withInitial(() -> 0); // 假设初始账户有100块钱
// private static ThreadLocal<Integer> balance = new ThreadLocal<>();
// private static ThreadLocal<Integer> cost = new ThreadLocal<>();
public int getBalance() {
return balance.get();
}
public int getCost() {
return cost.get();
}
// 2。 消费
public void spendMoney() {
int balanceNow = balance.get();
int costNow = cost.get();
balance.set(balanceNow - 10); // 每次花10块钱
cost.set(costNow + 10);
}
public void removeBalance(){
balance.remove();
balance = null;
}
public void removeCost(){
cost.remove();
cost = null;
}
public void removeAll(){
removeBalance();
removeCost();
}
}
}
- 重点看 remove 方法
public void removeBalance(){
balance.remove();
balance = null;
}
public void removeCost(){
cost.remove();
cost = null;
}
public void removeAll(){
removeBalance();
removeCost();
}
- 当 balance 与 cost 调用 remove 方法后,GC后续进行垃圾回收
=== 点击查看top目录 ===
六、番外篇
下一章节:【线程】InheritableThreadLocal 剖析 (十六)
上一章节:【线程】ThreadLocal 剖析 (十四)