强引用，软引用，弱引用与虚引用

强引用：（StrongReference）

强引用指普通的对象引用

例如：

StringBuffer str = new StringBuffer("hello world");

局部变量str会被放到栈里，而StringBuffer实例对象会被放在堆内，局部变量str指向堆内的StringBuffer对象，通过str可以操作该对象，那么str就是StringBuffer的强引用

StringBuffer str1 = str;

当发生了这条语句，则

 此时这两个引用都是强引用

强引用具备如下特点：

　　1、通过强引用可以直接访问目标对象

　　2、强引用所指向的对象在任何时候都不会被系统回收，虚拟机宁愿抛出OOM(内存溢出)异常，也不会回收强引用所指向的对象

　　3、强引用可能导致内存泄漏(站着空间不释放，积累的多了内存泄漏会导致内存溢出)

软引用：（SoftReference）

软引用描述一些还有用但非必需的对象，用java.lang.ref.SoftReference类表示，对于软引用关联的对象GC未必会一定会收，只有当内存资源紧张时，软引用对象才会被回收，所以软引用对象不会引起内存溢出(OOM)

import 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 "User [id=" + id + ", name=" + name + "]";
        }
        
        
    }
    
    public static void main(String[] args) {
        User u = new User(1,"吉米");
        //从强引用中获取软引用
        SoftReference<User> sr = new SoftReference<User>(u);
        //将强引用去除
        u = null;
        // get方法返回此引用对象的指示对象。用来获取与软引用关联的对象的引用
        System.out.println(sr.get());
        System.out.println("After GC");
        System.gc();
        System.out.println(sr.get());
        
        
        //这样测试出来，软引用可能不会被gc回收，此时需要模拟一下内存很紧张的状态
        byte b[] = new byte[1024*925*77];
        System.gc();
        System.out.println(sr.get());
        
    }
}

输出：在-Xmx10m下输出
User [id=1, name=吉米]  //第一次从软引用中获取数据
After GC   
User [id=1, name=吉米]   //GC没有清除软引用
null                                 //由于内存紧张，软引用被GC清理

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

弱引用：（WeakReference）

弱引用是比软引用还弱的引用，在系统进行GC 时，只要发现弱引用，不管系统的堆空间是用了一点还是用了一大半，都会回收弱引用的对象。但是通常GC线程的优先级较低，因此不能立即发现持有弱引用的对象，在这种情况下弱引用对象可以存在较长的时间，一旦弱引用对象被回收，弱引用对象会加到一个注册的引用队列中去

 

 弱引用代码：

import 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=" + id + ", name=" + name + "]";
        }
        
    }
    
    public static void main(String[] args) {
        User u = new User(1,"geym");
        //创建软引用对象
        WeakReference<User> wr = new WeakReference<User>(u);
        System.out.println(wr.get());
        System.gc();
        System.out.println("After GC:");
        System.out.println(wr.get());
    }
}

输出：

[id=1, name=geym]
After GC:
null

根据软引用和弱引用的特性，非常适合保存一些可有可无的缓存，如果这么做，当系统内存空间不足时，会及时回收他们，不会导致内存溢出，当系统内存资源充足时，这些还存有可以存在相当长的时间，提升系统速度。

虚引用：（PhantomReference）（对象回收和跟踪）

虚引用是所有引用中最弱的一个持有一个虚引用的对象，和没有引用一样，随时都有可能会被垃圾回收器回收，当用虚引用的get方法去尝试获得强引用对象时总是会失败，并且他必须和引用队列一起使用，用于跟踪垃圾回收过程，当垃圾回收器回收一个持有虚引用的对象时，在回收对象后，将这个虚引用对象加入到引用队列中，用来通知应用程序垃圾的回收情况。

虚引用代码：

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

public class PlantomRef {
    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 "User [id=" + id + ", name=" + name + "]";
        }
        
    }
    
    public static void main(String[] args) {
        User u = new User(1,"吉米");
        ReferenceQueue<? super User> queue = new ReferenceQueue<User>();
        PhantomReference<User> pr = new PhantomReference<User>(u,queue);
        System.out.println(pr.get());
        
    }
    
    
    
}

输出为null

由于虚引用可以跟踪对象的回收时间，所以可以将一些资源的释放操作放置在虚引用中执行和记录