【线程】ThreadLocal 内存泄漏问题（十五）

我的原则：先会用再说，内部慢慢来。
学以致用，根据场景学源码

---

一、架构图

=== 点击查看top目录 ===

二、为什么会内存泄漏？

1. 看下图，当 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是如何减少内存泄漏的?

【线程】ThreadLocal 剖析 （十四）

4.1. 泄漏在哪里？

看上图 === gc回收threadLocal2 ===，虽然weakReference的 threadLocal2占用的空间被回收了，但是Entry2(k=null,v=v2) 这个没用了，属于脏数据。但是没被回收，所以泄漏在这里。除非线程 thread 结束。

4.2 线程什么时候终结？

1. 如果你是 new 一个的话，那么 run方法跑完的了，自然就会结束
2. 在实际使用中我们都是会用线程池去维护我们的线程，比如在Executors.newFixedThreadPool()时创建线程的时候，为了复用线程是不会结束的。所以上面的 Entry2(k=null,v=v2) 就会一直存在，所以就泄漏了。

4.3. 源码如何解决？

在threadLocal的生命周期里（set,getEntry,remove）里，都会针对key为null的脏entry进行处理。每次调用都会去处理一下脏 Entry.

4.4 源码已经解决了，为什么依旧会泄漏？

因为你得调用4.3所说的那几个方法（set,getEntry,remove），如果你一直不去理他，不去调用，那么他自然在。这个解决方案很被动！！！

=== 点击查看top目录 ===

五、人工如何解决内存泄漏？

• 上述 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 剖析 （十四）