java四种引用类型(强引用 软引用 弱引用 虚引用)

强引用

强引用就是程序中一般使用的引用类型，强引用的对象是可触及的，不会被回收。

• 强引用可以直接访问目标对象
• 强引用所指向的对象在任何时候都不会被系统回收，虚拟机宁愿抛出OOM异常，也不会回收强引用所指的对象
• 强引用可能会导致内存泄漏

软引用

如果一个对象只持有软引用，那么当堆空间不足时，就会被回收。软引用使用java.lang.ref.SoftReference类实现。

下面演示软引用在堆内存不足的情况下被回收

public class SoftRef {

    public static class User {
        public int id;
        public String name;

        public User(int id, String name) {
            this.id = id;
            this.name = name;
        }

        @Override
        public String toString() {
            return "[id=" + String.valueOf(id) + ",name=]" + name;
        }
    }

    public static void main(String[] args) {
        //user为强引用
        User user = new User(1, "changyy");
        SoftReference<User> userSoftReference = new SoftReference<>(user);
        user = null;

        System.out.println(userSoftReference.get());
        System.gc();
        System.out.println("After GC:");
        System.out.println(userSoftReference.get());

        byte[] b = new byte[1024 * 900 * 7];
        System.gc();
        System.out.println(userSoftReference.get());

    }

}

使用参数-Xmx10m

[id=1,name=]changyy		//第一次从软引用中获取数据
After GC:				
[id=1,name=]changyy		//GC没有清除软引用
null					//由于堆内存不足，软引用被清除

可以得出结论：GC未必会回收软引用的对象，但是当内存资源紧张时，软引用对象会被回收，所以软引用不会导致内存溢出。

每一个软引用都可以附带一个引用队列，当对象的可达性发生改变时（由可达变为不可达），软引用对象就会进入引用队列，通过这个引用队列，可以跟踪对象的回收情况

public class SoftRefQ {

    public static class User {
        public int id;
        public String name;

        public User(int id, String name) {
            this.id = id;
            this.name = name;
        }

        @Override
        public String toString() {
            return "[id=" + String.valueOf(id) + ",name=]" + name;
        }
    }

    static ReferenceQueue<User> softQueue = null;

    public static class CheckRefQueue extends Thread {

        @Override
        public void run() {
            //跟踪引用队列
            while (true) {
                if (softQueue != null) {
                    UserSoftReference obj = null;
                    try {
                        obj = (UserSoftReference) softQueue.remove();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (obj != null) {
                        System.out.println("user id " + obj.uid + " is delete");
                    }
                }
            }
        }
    }

    //自定义一个软引用类，扩展软引用的目的是记录User.uid,后续在引用队列中就可以通过这个uid字段知道哪个User实例被回收了
    public static class UserSoftReference extends SoftReference<User> {

        int uid;

        public UserSoftReference(User referent, ReferenceQueue<? super User> q) {
            super(referent, q);
            uid = referent.id;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t = new CheckRefQueue();
        t.setDaemon(true);
        t.start();
        User u=new User(1,"changyy");
        softQueue=new ReferenceQueue<User>();
        //创建软引用，指定一个软引用队列，当给定的对象实例回收时，就会加入这个引用队列，通过访问该队列可以追踪到对象的回收情况
        UserSoftReference userSoftReference=new UserSoftReference(u,softQueue);
        u=null;
        System.out.println(userSoftReference.get());
        System.gc();
        //内存足够 不会被回收
        System.out.println("After GC:");
        System.out.println(userSoftReference.get());

        System.out.println("try to create byte array and GC");
        byte[]bytes=new byte[1024*900*7];
        System.gc();
        System.out.println(userSoftReference.get());

        Thread.sleep(1000);
    }
}

使用参数-Xmx:10m 运行结果

[id=1,name=]changyy						//第一次从软引用获得对象
After GC:							
[id=1,name=]changyy						//GC后，软引用对象没有回收
try to create byte array and GC			//创建数组，耗尽内存
user id 1 is delete						//引用队列探测到对象被删除
null									//对象已经被回收，无法再通过软引用获取对象

弱引用

弱引用在 系统GC时，只要发现是弱引用，不管系统堆内存使用情况如何，都会将对象进行回收。但是，由于垃圾回收器的线程通常优先级很低，并不一定能很快地发现持有弱引用的对象。在这种情况下，弱引用会存存活很长时间，一旦一个弱引用对象被垃圾回收器回收，便会加入一个注册的引用队列。弱引用使用java.lang.ref.WeakReference类实现。

public class WeakRef {

    public static class User {
        public int id;
        public String name;

        public User(int id, String name) {
            this.id = id;
            this.name = name;
        }

        @Override
        public String toString() {
            return "[id=" + String.valueOf(id) + ",name=]" + name;
        }
    }

    public static void main(String[] args) {
        User user = new User(1, "changyy");
        WeakReference<User> userWeakReference = new WeakReference<>(user);
        user = null;
        System.out.println(userWeakReference.get());
        System.gc();
        System.out.println("After GC");
        System.out.println(userWeakReference.get());
    }
}

[id=1,name=]changyy
After GC
null

可以看到在GC之后 弱引用对象立即被清除

弱引用和软引用一样，可以在构造器引用时，指定一个引用队列，当弱引用对象被回收时，就会加入指定的引用队列，通过这个队列来跟踪对象的回收情况。

注意

软引用、弱引用都非常适合保存那些可有可无的缓存数据，如果这么做，当系统内存不足时，这些缓存数据就会被回收，不会导致内存溢出，而当内存资源充足时，这些缓存数据又可以存在相当长的时间， 从而起到让系统加速的作用。

虚引用

虚引用是所有 引用类型中最弱的一个，一个持有虚引用的对象，和没有引用几乎是一样的，随时都有可能被垃圾回收器回收。当试图通过虚引用的get()方法取得引用时，总是失败。并且虚引用必须和引用队列一起使用，它的作用在于跟踪垃圾回收过程。

public class TraceCanReliveObj {

    public static TraceCanReliveObj obj;

    static ReferenceQueue<TraceCanReliveObj> phantomQueue = null;

    public static class CheckRefQueue extends Thread {
        @Override
        public void run() {
            while (true) {
                if (phantomQueue!=null){
                    PhantomReference<TraceCanReliveObj> obj=null;
                    try {
                        obj=(PhantomReference<TraceCanReliveObj>)phantomQueue.remove();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (obj!=null){
                        System.out.println("TraceCanReliveObj is delete by GC");
                    }
                }
            }
        }
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("CanReliveObj finalize called");
        obj=this;
    }

    @Override
    public String toString() {
        return "I am CanReliveObj";
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t=new CheckRefQueue();
        t.setDaemon(true);
        t.start();

        phantomQueue=new ReferenceQueue<TraceCanReliveObj>();
        obj=new TraceCanReliveObj();
        PhantomReference<TraceCanReliveObj> phantomReference=new PhantomReference<>(obj,phantomQueue);
        obj=null;
        System.gc();
        Thread.sleep(1000);
        if (obj==null){
            System.out.println("obj 是 null");
        }else{
            System.out.println("obj 可用");
        }

        System.out.println("第2次GC");
        obj=null;
        System.gc();
        Thread.sleep(1000);
        if (obj==null){
            System.out.println("obj 是 null");
        }else{
            System.out.println("obj 可用");
        }
    }

}

CanReliveObj finalize called
obj 可用
第二次GC
TraceCanReliveObj is delete by GC
obj 是 null