JAVA并发（3）—线程运行时发生GC，会回收ThreadLocal弱引用的key吗？

在《深入理解Java虚拟机》中，是这样描述引用的：

无论是通过引用计数算法判断对象的引用数量，还是通过可达性分析法判断对象的引用链是否可达，判断对象是否存活都与“引用”相关。在JDK1.2以前，Java中的引用定义很传统：如果reference类型的数据中存储的数值代表的是另外一块内存的起始地址，就称这块内存代表着一个引用。当然这种定义很是纯粹，但是太过于狭隘，一个对象在这种定义下只有被引用和没有被引用两种状态。但是对于描述一些特殊的对象却无能为力，例如：我们希望描述一类这样的对象：当内存空间还足够时，则能保存在内存中；如果内存空间在进行GC后依旧非常紧张，则可以抛弃这些对象。
在JDK1.2之后，Java对引用的概念进行了扩充，将引用分为了强引用、软引用、弱引用、虚引用4种，这4种引用的强度依次逐渐减弱。

• 强引用（Strong Refernce）：在程序代码中普遍存在，类似于“Object obj=new Object()”，只要对象被强引用持有，那么垃圾回收器永远不会回收被引用的对象；
• 软引用（Soft Reference）：在系统将要发生内存溢出之前，会回收软引用持有的对象。若这次回收还没有足够的内存，才会抛出内存溢出异常。在JDK1.2之后，提供了SoftReference类实现软引用。
• 弱引用（Weak Reference）：被弱引用关联的对象只要发生GC，均要被回收。在JDK1.2 之后，提供了WeakReference类来实现弱引用。
• 虚引用（PhantomReference）：一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象的实例。

---

当然，能看到这篇文章的人，了解Java中的引用，也了解ThreadLocal的设计。才会提出这样一个经过思考的问题。

但实际上并不是很了解引用与对象的关系。

1. 引用&&对象

1.1 多个引用指向同一个对象

对象和引用是两个概念。如图1所示，首先我们创建出对象new A()，该对象并未被引用所持有。

图1-内存中对象.png

如图2所示，执行A a=new A()，该对象会被一个强引用持有。只要该对象一致被强引用持有，那么该对象不会被回收。

图2-强引用持有对象.png

如图三所示，执行A=null，强引用指向null，该对象目前不会被引用所持有。

图3-对象不被持有.png

如图4所示，一个对象可以被多个引用持有。即使其中一个引用指向null，还可以通过另外一个引用获取到该对象。

图4-多个引用指向同一个对象.png

1.2 弱引用和对象

new出来的对象。被不同类型的引用持有，那么对象被回收的时期不同。实际在开发过程中，可以选择合适引用去持有对象。例如：选择软引用持有缓存对象，当发生内存溢出时，可以回收缓存对象以防止内存溢出。

案例1：若发生GC后，被弱引用持有的对象是否会被回收？

public static void testWeakReference2() {  
    //创建出对象，并且被强引用持有  
    User user = new User("tom", "11");  
    //该对象又被弱引用持有  
    WeakReference weakUser = new WeakReference<>(user);  
    //user=null;  (解决方案中打开注释)
    //通过弱引用，打印对象  
    System.out.println("GC前：" + JSON.toJSONString(weakUser.get()));  
    System.out.println("发生了显式GC...");  
    System.gc();  
    //通过弱引用，打印对象  
    System.out.println("GC后：" + JSON.toJSONString(weakUser.get()));  
}   

图5-案例1，对象与引用的关系.png

可以看到，该对象此时被两个引用持有。即使发生了GC，但是强引用依旧持有了该对象，所以该对象不会被回收。

图7-输出结果.png

解决方案：将强引用设置为null。或该对象不被强引用持有。

public static void testWeakReference() {  
    //该对象直接被弱引用持有！  
    WeakReference weakUser = new WeakReference<>(new User("tom", "12"));  
    System.out.println("GC前：" + JSON.toJSONString(weakUser.get()));  
    System.out.println("发生了显式GC...");  
    System.gc();  
    System.out.println("GC后：" + JSON.toJSONString(weakUser.get()));  
} 

执行结果：可以看到，被弱引用持有的对象已经被回收，最终返回null；

图8-输出结果.png

案例2：若发生GC后，被弱引用持有的对象是否会被回收？

public static void testWeakReference() {  
    //该对象直接被弱引用持有！  
    WeakReference weakUser = new WeakReference<>(new User("tom", "12"));  
    //该对象又被强引用所持有  
    User user = weakUser.get();  
    System.out.println("GC前：" + JSON.toJSONString(user));  
    System.out.println("发生了显式GC...");  
    System.gc();  
    System.out.println("GC后：" + JSON.toJSONString(weakUser.get()));  
}  

对象创建完成后，只被弱引用持有，但是User user = weakUser.get();后，该对象又被强引用持有，所以即使再次发生GC，该对象也不会被回收。

图9-输出结果.png

1.3 总结

回到原点，若线程运行时发生GC，ThreadLocal弱引用的key是否会被回收？

每个线程中均存在ThreadLocalMap，实际是一个Entry[]数组。key是弱引用指向的ThreadLocal对象。

而我们一般使用ThreadLocal是这样的：

    private static ThreadLocal threadLocal = new ThreadLocal<>();
    public static void testThreadLocal() {
        threadLocal.set("aaa");
        System.gc();
        String s = threadLocal.get();
        System.out.println(s);
    }

ThreadLocal已经被强引用持有。是不是在发生GC时回收key指向的对象。

若不同线程的ThreadLocalMap持有一个变量，那么修改value会不会影响所有的ThreadLocal？

@Slf4j
public class Test {
    private static ThreadLocal threadLocal = ThreadLocal.withInitial(Acc::new);
    public static void main(String[] args) {
        Acc acc = threadLocal.get();
        acc.setName("tom");
        new Thread() {
            @Override
            public void run() {
                //线程1将main线程的value存入
                threadLocal.set(acc);
                //线程1修改value
                acc.setName("xixi");
                Acc acc1 = threadLocal.get();
                log.info(JSON.toJSONString(acc1));
            }
        }.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //最终主线程的value也会被改变。
        log.info(JSON.toJSONString(threadLocal.get()));
    }
}

ThreadLocalMap的值最终被改变.png

推荐阅读

谈谈Java引用和Threadlocal的那些事