Java的四种引用

柔情只为你懂 2021-09-26 13:08 393阅读 0赞

Java的四种引用：  
Java的四种引用由强到弱分为：强引用->软引用->弱引用->虚引用。  
1.强引用  
不会被GC回收，平时用得最多的就是强引用。Object o = new Object()，o就是一个强引用。如果一个对象是强引用，那么即使内存空间不足，JVM宁愿抛出OutofMemoryError异常，也不会强制回收强引用对象来解决内存不足问题。  
例如：

public class Strong { 
        /** * @param args */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            //设置-Xms2m -Xmx2m
            String[] str = new String[100000000];
            for(int i = 0;i<str.length;i++){
                str[i] = new String("hello world"+i);
            }
        }
    }

实验结果：抛出内存溢出异常  
![这里写图片描述][SouthEast]  
2.软引用(SoftReference)  
如果一个对象只具有软引用，那么内存不足是垃圾回收器自动回收，如果内存充足时GC不清理它。软引用可以和一个引用队列联合使用，如果软引用所引用的对象被垃圾回收器回收，JVM就会把这个软引用加入到与之关联的引用队列中。  
应用场景：软引用可以用来实现内存敏感的高速缓存。  
例如：

import java.lang.ref.SoftReference;
    
    public class Soft { 
    
        /** * @param args */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            //设置-Xms2m -Xmx2m
            //测试1：测试调用垃圾回收器是否会清理
            SoftReference<String> soft = new SoftReference<String>(new String("hell world！"));
            System.out.println(soft.get());//调用前
            System.gc();
            System.out.println(soft.get());//调用后
            //实验结果表明：软引用在内存充足时调用GC是不会被回收的
            System.out.println("****************");
            //实验2：测试软引用在内存不足是被回收
            @SuppressWarnings("unchecked")
            SoftReference<String>[] referent = new SoftReference[100000];
            for (int i = 0; i < referent.length; i++) {
                referent[i] = new SoftReference<String>(new String("hell world "+i));
            }
            System.out.println(referent[100].get());// “null”
            System.out.println(referent[99998].get());// “hell world 99998”
        }
    }

实验结果：  
![这里写图片描述][SouthEast 1]

3.弱引用(WeakReference)  
弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。 弱引用可以和一个引用队列联合使用，如果软引用所引用的对象被垃圾回收器回收，JVM就会把这个弱引用加入到与之关联的引用队列中。  
例如：

import java.lang.ref.WeakReference;
    
    public class Weak { 
    
        /** * @param args */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            //设置-Xms2m -Xmx2m
            //测试1：测试弱引用调用GC时被回收
            WeakReference<String> wReference = new WeakReference<String>(new String("Hello World!"));
            System.out.println(wReference.get());//Hello World!
            System.gc();
            System.out.println(wReference.get());//null
            //测试2：内存不足时自动回收
            @SuppressWarnings("unchecked")
            WeakReference<String>[] referent = new WeakReference[100000];
            for (int i = 0; i < referent.length; i++) {
                referent[i] = new WeakReference<String>(new String("hell world "+i));
            }
            System.out.println(referent[100].get());// “null”
            System.out.println(referent[99998].get());// “hell world 99998”
        }
    }

实验结果：  
![这里写图片描述][SouthEast 2]  
4.虚引用(PhantomReference)  
虚引用和软引用、弱引用的区别在于：虚引用必须和引用队列联合使用，当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收之前将这个虚引用加入到与之关联的引用队列中。  
应用场景：主要被用来跟踪对象被垃圾回收器回收的活动。  
例如：

import java.lang.ref.PhantomReference;
    import java.lang.ref.Reference;
    import java.lang.ref.ReferenceQueue;
    
    public class Phantom { 
    
        /** * @param args */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            //设置-Xms2m -Xmx2m
            //测试1: 虚引用永远无法使用 get(),被垃圾回收器回收前将其添加到引用队列
            //虚引用必须与引用队列一起使用
            ReferenceQueue<String> q = new ReferenceQueue<String>();
            PhantomReference<String> pReference = new PhantomReference<String>(new String("Hello World"), q);
            System.out.println(pReference.get());//null
            System.out.println(q.poll()==pReference);//false
            System.gc();//告诉垃圾收集器打算进行垃圾收集，而垃圾收集器进不进行收集是不确定的 
            System.runFinalization();//强制调用已经失去引用的对象的finalize方法 
            System.out.println(q.poll()==pReference);//true 
            //测试2：跟强引用类似的一点是，不会根据内存情况自动回收
            Reference<String>[] referent = new PhantomReference[100000];
            ReferenceQueue<String> queue = new ReferenceQueue<String>();
            for (int i = 0; i < referent.length; i++) {
                referent[i] = new PhantomReference<String>(new String("mybean:" + i), queue);
            }
        }
    
    }

实验结果：  
![这里写图片描述][SouthEast 3]  
附：  
JVM内存：  
JVM的内存 = 年轻代(Young) + 年老代(Tenured) + 持久代  
\-Xms: 设置初始JVM内存大小  
\-Xmx: 设置最大JVM内存大小  
上述实验环境均设置为2M  
设置方式：右键->Run as->Run Configurations->Arguments->VM arguments

[SouthEast]: /images/20210923/d4754df8257b47f8ba3fe9290dde420b.png
[SouthEast 1]: /images/20210923/c4f047d0183f44fb91df47f3cc90a589.png
[SouthEast 2]: /images/20210923/d0f0093ee81043d4829c04c51499c0e5.png
[SouthEast 3]: /images/20210923/db2790472e484a7eb6a1a76a878edb9f.png