Java进阶之深入理解JVM（六）

深入理解JVM之四种对象引用方式

强引用 软引用 弱引用 虚引用

1.强引用（默认的支持方式）

假设出现了异常或者OOM情况，只要是强引用的对对象，都不会被回收！

强引用就是导致内存泄漏原因之一

package JVM.Import;

//-XX:+PrintGCDetails
public class ImportTest01 {
    public static void main(String[] args){
        Object o1 = new Object();
        Object o2 = o1;
        o1 = null;

        System.gc();
        System.out.println(o1);
        System.out.println(o2);
    }
}

2.软引用

相对于强引用，弱化了，如果系统内存充足，GC不会回收此对象，但是内存不足的情况，就会回收对象

package JVM.Import;

import java.lang.ref.SoftReference;

//-Xms5m -Xmx5m -XX:+PrintGCDetails  开启内存显示后的输出结果,印证：内存不足的情况，就会回收对象
/*java.lang.Object@1b6d3586
        java.lang.Object@1b6d3586
        null
        null*/
public class ImportTest02 {
    public static void main(String[] args){
        Object o1 = new Object();
        SoftReference<Object> o2 = new SoftReference<>(o1);//jdk自带软引用方式

        System.out.println(o1);
        System.out.println(o2.get());

        System.out.println("print the separation character ==========");
        o1 = null;

        try {
            byte[] bytes = new byte[10 * 1024 * 1024];
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println(o1);
            System.out.println(o2.get());
        }

    }
}

3.弱引用

无论内存是否充足，只要触发了GC，就会回收该对象

package JVM.Import;

import java.lang.ref.WeakReference;

/*输出结果：
        java.lang.Object@1b6d3586
        java.lang.Object@1b6d3586
        print the separation character ==========
        null
        null*/
public class ImportTest03 {
    public static void main(String[] args){
        Object o1 = new Object();
        WeakReference<Object> o2 = new WeakReference<>(o1);

        System.out.println(o1);
        System.out.println(o2.get());

        System.out.println("print the separation character ==========");
        o1 = null;
        System.gc();

        System.out.println(o1);
        System.out.println(o2.get());

    }
}

4.虚引用

虚引用：就是没有这个引用

主要作用：跟踪对象的垃圾回收状态！

package JVM.Import;

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.util.concurrent.TimeUnit;

/* 输出结果
        java.lang.Object@74a14482
        null
        null
        This is the separation charcter
        null
        null
        java.lang.ref.PhantomReference@1540e19d*/
public class ImportTest04 {
    public static void main(String[] args) throws InterruptedException {
        Object o1 = new Object();

        //虚拟引用PhantomReference 需要结合队列使用
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        PhantomReference<Object> objectPhantomReference = new PhantomReference<>(o1, referenceQueue);

        System.out.println(o1);
        System.out.println(objectPhantomReference.get());
        System.out.println(referenceQueue.poll());
        System.out.println("This is the separation charcter");

        o1 = null;
        System.gc();
        TimeUnit.SECONDS.sleep(1);
        System.out.println(o1);
        System.out.println(objectPhantomReference.get());
        
        //通知机制
        //通过队列来检测那些对象被清理了，可以处理一些善后的工作
        System.out.println(referenceQueue.poll());

    }
}

软引用和弱引用的使用场景

假设现在有一个应用，需要读取大量的本地的图片

1.如果每次读取图片都要从硬盘中读取，影响性能

2.一次加载到内存中，可能造成内存溢出

解决思路：

1.使用一个HashMap保存图片的路径和内容；

2.内存足够，不清理；

3.内存不足，清理加载到内存中的数据；

HashMap<String,SoftRefence<Pic>> stringSoftReferenceHashMap = new HashMap<>();