Java 四种引用

Java 四种引用

强引用：

  如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。 只要引用存在，垃圾回收机制即使抛出OutOfMemor也不会进行回收

Object obj = new Object();

 

 

软引用：

当内存不足的时候，可以回收，如果一个对象只具有软引用，那就类似于可有可无的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存

看代码：

 

/**
 * 版权所有 (c) 2016，小明有限公司  
 */
package helloTest;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;

/**
 * 类说明：
 * 
 * <pre>
 * Modify Information:
 * Author        Date          Description
 * ============ =========== ============================
 * wangxiaoming      2016-7-12    Create this file
 * </pre>
 * 
 */
public class TestJava4Reference {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            soft();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
    public static void soft() throws Exception { 
        /*代表软引用的类：java.lang.ref.SoftReference
        代表弱引用的类：java.lang.ref.WeakReference
        代表虚引用的类：java.lang.ref.PhantomReference
        他们同时继承了：java.lang.ref.Reference*/
        //软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
       /* ReferenceQueue refQueue = new ReferenceQueue(); 
        SoftReference softRef = new SoftReference(obj, refQueue); */
        Object obj = new Object(); 
        SoftReference<Object> softRef = new SoftReference<Object>(obj);
        System.out.println(softRef.get()); //有时候会返回Null 
        // java.lang.Object@f9f9d8 System.out.println(refQueue.poll());
        // null
        // 清除强引用,触发GC
        
        obj = null;
        //System.gc(); 
        System.out.println(softRef.get()); 
        //Thread.sleep(200); 
        //System.out.println(refQueue.poll()); 
    }

}

 

 

弱引用：

 

 

如果一个对象只具有弱引用，那就类似于可有可无的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，并且可回收（即可达性分析判断无任何引用）不管当前内存空间足够与否，都会回收它的内存。

/**
 * 版权所有 (c) 2016，小明有限公司  
 */
package helloTest;


import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.util.WeakHashMap;


/**
 * 类说明：
 * 
 * <pre>
 * Modify Information:
 * Author        Date          Description
 * ============ =========== ============================
 * wangxiaoming      2016-7-12    Create this file
 * </pre>
 * 
 */
public class TestJava4Reference {


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            soft();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


    }
    public static void soft() throws Exception { 
        /*代表软引用的类：java.lang.ref.SoftReference
        代表弱引用的类：java.lang.ref.WeakReference
        代表虚引用的类：java.lang.ref.PhantomReference
        他们同时继承了：java.lang.ref.Reference*/
        //软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
       /* ReferenceQueue refQueue = new ReferenceQueue(); 
        SoftReference softRef = new SoftReference(obj, refQueue); */
       /* Object obj = new Object(); 
        SoftReference<Object> softRef = new SoftReference<Object>(obj);
        System.out.println(softRef.get()); //有时候会返回Null 
        // java.lang.Object@f9f9d8 System.out.println(refQueue.poll());
        // null
        // 清除强引用,触发GC
        
        obj = null;
        //System.gc(); 
        System.out.println(softRef.get()); */
        //Thread.sleep(200); 
        //System.out.println(refQueue.poll()); 
        
        //弱引用
        Object obj = new Object();
        WeakReference<Object> weakReference = new WeakReference<Object>(obj);
        obj = null;
        System.gc();
        System.out.println(weakReference.get());// 有时候会返回Null
        System.out.println(weakReference.isEnqueued());//判断是否有垃圾回收标记，表示即将回收的垃圾
        
    }


}

 

 

 

虚引用：

"虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。

/**
 * 版权所有 (c) 2016，小明有限公司  
 */
package helloTest;

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.util.WeakHashMap;

/**
 * 类说明：
 * 
 * <pre>
 * Modify Information:
 * Author        Date          Description
 * ============ =========== ============================
 * wangxiaoming      2016-7-12    Create this file
 * </pre>
 * 
 */
public class TestJava4Reference {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            soft();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
    public static void soft() throws Exception { 
        /*代表软引用的类：java.lang.ref.SoftReference
        代表弱引用的类：java.lang.ref.WeakReference
        代表虚引用的类：java.lang.ref.PhantomReference
        他们同时继承了：java.lang.ref.Reference*/
        //软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
       /* ReferenceQueue refQueue = new ReferenceQueue(); 
        SoftReference softRef = new SoftReference(obj, refQueue); */
       /* Object obj = new Object(); 
        SoftReference<Object> softRef = new SoftReference<Object>(obj);
        System.out.println(softRef.get()); //有时候会返回Null 
        // java.lang.Object@f9f9d8 System.out.println(refQueue.poll());
        // null
        // 清除强引用,触发GC
        
        obj = null;
        //System.gc(); 
        System.out.println(softRef.get()); */
        //Thread.sleep(200); 
        //System.out.println(refQueue.poll()); 
        
       /* //弱引用
        Object obj = new Object();
        WeakReference<Object> weakReference = new WeakReference<Object>(obj);
        obj = null;
        System.gc();
        System.out.println(weakReference.get());// 有时候会返回Null
        System.out.println(weakReference.isEnqueued());//判断是否有垃圾回收标记，表示即将回收的垃圾
*/        
        // 虚引用
        Object obj = new Object();
        ReferenceQueue refQueue = new ReferenceQueue();
        PhantomReference<Object> phantomReference = new PhantomReference<Object>(obj, refQueue);
        System.out.println(phantomReference.get());  // 永远返回Null
        System.out.println(phantomReference.isEnqueued()); //返回时否从队列中删除
    }

}