关于值类型和引用类型的话题，C++、JAVA、python、go、C#等等高级语言都有相关的概念，只要理解了其底层工作原理，可以说即使是不同的语言，在面试学习工作实践中都可以信手拈来(不要太纠集语言)，当然此处我选择了JAVA，虽然我是搞C++的，具体原因都懂就不废话了。

一、值类型与引用类型

　　1、变量初始化

int num=10;
String str="hello"

　　2、变量赋值
 　　从上图可以显而易见，num是int基本类型变量，值就直接保存在变量中。str是String引用类型变量，变量中保存的只是实际对象对应的地址信息，而不是实际对象数据。对于而这特性，如下：

num=20;
str="java";

　　对于基本类型变量num，赋值运算符将会直接修改变量的值，原来的数据将被覆盖掉，被替换为新的值。对于引用类型变量str，赋值运算符只会改变变量中所保存的对象的地址信息，原来对象的地址被覆盖掉，重新写入新对象的地址数据。但原来的对象本身并不会被改变，只是不再被任何引用所指向的对象，即“垃圾对象”，后续会被垃圾回收器回收。

　　3、函数传参

// 基本类型参数，原始value不会被更改
    public void func(int value) {
        value = 100;
    }

    // 对于没有提供修改自身的成员方法引用类型，原始str不会被更改
    public void func(String str) {
        str = "hello";
    }

    StringBuilder sb = new StringBuilder("test");

    // 对于提供修改自身的成员方法引用类型，原始的sBuilder会被更改
    public void func(StringBuilder sBuilder) {
        sBuilder.append("aa");
    }

    // 原始的sBuilder不会被更改
    public void test(StringBuilder sBuilder) {
        sBuilder = new StringBuilder("111");
    }

说明：对于第三种情况：

对于第四种情况：

二、数据存储方式

　　1、局部变量/方法参数

　　对于局部变量和方法传递的参数在jvm中的存储方式是相同的，都是存储在栈上开辟的空间中。方法参数空间在进入方法时开辟，方法退出时进行回收。以32为JVM为例，boolean、byte、short、char、int、float以及对应的引用类型都是分配4字节大小的空间，long、double分配8字节大小空间。对于每一个方法来说，最多占用空间大小是固定的，在编译时就已经确定了。当在方法中声明一个int变量i=0或Object变量obj=null时，此时仅仅在栈上分配空间，不影响到堆空间。当new Object()时，将会在堆中开辟一段内存空间并初始化Object对象。

　　2、数组类型引用和对象

　　当声明数组时，int[]  arr=new int[2];数组也是对象，arr实际上是引用，栈上占用4个字节大小的存储空间，而是会在堆中开辟相应大小空间进行存储，然后arr变量指向它。当声明一个二维数组时，如：int[][]  arr2=new int[2][4],arr2同样在栈中占用4个字节，在堆内存中开辟长度为2，类型为int[]的数组对象，然后arr2指向这个数组。这个数组内部有两个引用类型(大小为4个字节)，分别指向两个长度为4类型为int的数组。内存分布如图：

所以当传递一个数组给一个方法时，数组的元素在方法内部是可以被修改的，但是无法让数组引用指向新的数组。其实，还可以声明:int [][]  arr3=new int[3][],内存分布如下：

　　3、String类型数据

　　对于String类型，其对象内部需要维护三个成员变量，char[]  chars，int  startIndex,  int  length。chars是存储字符串数据的真正位置，在某些情况下是可以共用的，实际上String类型是不可变类型。例如：String  str=new String("hello")，内存分布如下：

三、JAVA引用类型

　　在JAVA中提供了四种引用类型：强引用、软引用、软引用和虚引用。在四种引用类型中，只有强引用FinalReference类型变量是包内可见的，其他三种引用类型均为public，可以在程序中直接使用。

　　1、强引用

　　强引用是使用最普遍的引用。如果一个对象具有强引用，那么垃圾回收器绝不会回收它。例如:StringBuilder sb = new StringBuilder("test");变量str指向StringBuffer实例所在的堆空间，通过str可以操作该对象。如下：

　　强引用特点：

• • 强引用可以直接访问目标对象
  • 只要有引用变量存在，垃圾回收器永远不会回收。JVM即使抛出OOM异常，也不会回收强引用所指向的对象。
  • 强引用可能导致内存泄漏问

 　　2、软引用

　　软引用是除了强引用外，最强的引用类型。可以通过java.lang.ref.SoftReference使用软引用。一个持有软引用的对象，不会被JVM很快回收，JVM会根据当前堆的使用情况来判断何时回收。当堆使用率临近阈值时，才会去回收软引用的对象。因此，软引用可以用于实现对内存敏感的高速缓存。SoftReference的特点是它的一个实例保存对一个Java对象的软引用，该软引用的存在不妨碍垃圾收集线程对该Java对象的回收。也就是说，一旦SoftReference保存了对一个Java对象的软引用后，在垃圾线程对 这个Java对象回收前，SoftReference类所提供的get()方法返回Java对象的强引用。一旦垃圾线程回收该Java对象之后，get()方法将返回null。

Object obj = new Object();
SoftReference<Object> sf = new SoftReference<Object>(obj);
obj = null;
sf.get();//有时候会返回null
sf是对obj的一个软引用，通过sf.get()方法可以取到这个对象，当这个对象被标记为需要回收的对象时，则返回null；

　　软引用主要用户实现类似缓存的功能，在内存足够的情况下直接通过软引用取值，无需从繁忙的真实来源查询数据，提升速度；当内存不足时，自动删除这部分缓存数据，从真正的来源查询这些数据。使用软引用能防止内存泄露，增强程序的健壮性。软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。也就是说，ReferenceQueue中保存的对象是Reference对象，而且是已经失去了它所软引用的对象的Reference对象。当调用它的poll()方法的时候，如果这个队列中不是空队列，那么将返回队列前面的那个Reference对象。在任何时候，都可以调用ReferenceQueue的poll()方法来检查是否有它所关心的非强可及对象被回收。如果队列为空，将返回一个null,否则该方法返回队列中前面的一个Reference对象。利用这个方法，可以检查哪个SoftReference所软引用的对象已经被回收，于是可以把这些失去所软引用的对象的SoftReference对象清除掉。

　　3、弱引用

　　弱引用是一种比软引用较弱的引用类型。在系统GC时，只要发现弱引用，不管系统堆空间是否足够，都会将对象进行回收。在java中，可以用java.lang.ref.WeakReference实例来保存对一个Java对象的弱引用。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱引用主要用于监控对象是否已经被垃圾回收器标记为即将回收的垃圾，可以通过弱引用的isEnQueued方法返回对象是否被垃圾回收器标记。弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

Object obj = new Object();
WeakReference<Object> wf = new WeakReference<Object>(obj);
obj = null;
wf.get();//有时候会返回null
wf.isEnQueued();//返回是否被垃圾回收器标记为即将回收的垃圾

　　4、虚引用

　　虚引用是所有类型中最弱的一个。一个持有虚引用的对象和没有引用几乎是一样的，随时可能被垃圾回收器回收，当试图通过虚引用的get()方法取得强引用时，总是会失败。并且虚引用必须和引用队列一起使用，它的作用在于检测对象是否已经从内存中删除，跟踪垃圾回收过程。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在垃圾回收后，销毁这个对象，将这个虚引用加入引用队列。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

Object obj = new Object();
PhantomReference<Object> pf = new PhantomReference<Object>(obj);
obj=null;
pf.get();//永远返回null
pf.isEnQueued();//返回是否从内存中已经删除

@Test
    public void test(){
        Map map;
        map = new WeakHashMap<String,Object>();
        for (int i =0;i<10000;i++){
            map.put("key"+i,new byte[i]);
        }
//        map = new HashMap<String,Object>();
//        for (int i =0;i<10000;i++){
//            map.put("key"+i,new byte[i]);
//        }
    }

　　使用-Xmx2M限定堆内存，使用WeakHashMap的代码正常运行结束，而使用HashMap的代码段抛出异常：java.lang.OutOfMemoryError: Java heap space。由此可见，WeakHashMap会在系统内存紧张时使用弱引用，自动释放掉持有弱引用的内存数据。但如果WeakHashMap的key都在系统内持有强引用，那么WeakHashMap就退化为普通的HashMap，因为所有的数据项都无法被自动清理。

前言：满纸荒唐言，一把辛酸泪；都云作者痴，谁解其中味。

一、概述

早在JDK1.2就把对象引用分为四种级别，从而使程序能更灵活控制它的生命周期，级别由高到底依次为：强 > 软 > 弱 > 虚引用。而GC垃圾回收器(Garbage Collection)对不同的类型有着不同的处理方法，了解这些处理方式有助于我们写出更高质量的代码。

在Java中，一切被视为对象，引用则是用来操纵对象的。对象和引用之间的关系可以用遥控器(引用)操控电视机(对象)这个场景来理解。遥控器只要链接电视机那么就能操控电视机，当我们尝试操控一个未指向任何对象的引用去操作对象时，就会出现空指针异常(NullPointerException)，就好比遥控器没有链接任何电视机，你却去操控遥控器，那是没法操控的。

Java有一个重要的有点就是通过垃圾回收机制自动管理内存回收，开发者不需要调用函数来释放内存，内存的分配是由程序分配的，而内存的回收由内存来完成。GC为了释放对象，会监控每一个对象的运行状态，包括申请，引用，被引用和赋值，GC都需要监控。监控对象的状态是为了更加准确地，及时地释放对象，释放对象的原则是该对象不再被引用。但是由于我们因为各种原因导致一些对象使用完后扔被持有引用而没有被回收导致内存泄漏。

总结了几个引用，下面我们在一一细讲：

二、引用详解

1.强引用

强引用（StrongReference）是使用最普遍的引用，如果一个对象属于强引用，不会自动被回收，当内存不足时，jvm宁愿抛出OOM使程序异常也不会回收强引用。当我们使用一个new关键字去创建对象的时候，这个对象的引用就是强引用。

//str表示强引用，指向new String()这个对象
String str = new String();

2.软引用

软引用（SoftReference）是除了强引用外，最强的引用类型。如果系统内存足够是不会回收软引用指向的对象的，如果系统内存不足那么就会回收。使用软引用，在OutOfMemory异常发生前，软引用指向的对象就可以被释放掉，避免内存达到上限避免crash的发生。

   //创建软引用实例，将bitmap存入到软引用中
   SoftReference<Bitmap> softReference = new SoftReference<>(bitmap);
   Bitmap bitmap = softReference.get()

   if ("内存不足"){
        //将软引用中的对象设置为null，否则既持有强引用也持有软引用是无法回收的
        bitmap = null;
        //通知系统回收
        System.gc();
    }

注意：软引用是在内存不足的时候才会被回收，我们调用System.gc()只是起到通知的作用，JVM什么时候扫描回收对象是它自己的态度决定，就算扫描到软引用也不一定会回收它，只有在内存不足的时候才回收。

我们尝试使用软引用来保存图片实例；

   ImageView imageView = findViewById(R.id.iv_soft_reference);
   Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher_round);
    //创建软引用实例，将bitmap存入到软引用中
   SoftReference<Bitmap> softReference = new SoftReference<>(bitmap);
        if (softReference.get() != null) {
        imageView.setImageBitmap(softReference.get());
    }

通过软引用的get()方法获取强Bitmap对象实例的引用，如果对象未被回收那么设置图片到控件上。如果内存紧张，系统就会GC，softReference.get()就不会反悔Bitmap对象，而是反回null，这里也需要把软引用获取的引用做空判断，避免空指针。

实际情况中，使用软引用虽然可以避免OOM，但是不适用于某些场景，使用的比较少。在Android开发中，一种更好的选择是LruCache，LRU是Least Recently Used的缩写，即“最近最少使用”的意思，它内部会维护一个固定大小的内存，当内存不足时，会把最近最少使用的数据移除掉。

3.弱引用

弱引用（WeakReference）是弱于软引用的引用类型，与软引用类似，不同的是弱引用不能阻止垃圾回收，在垃圾回收机制运行时，如果一个对象的引用是弱引用的话，不管内存空间是否足够，对象都会被回收。弱引用常常被用于防止内存泄漏，最常见的是单例和Handler造成的内存泄漏。

//弱引用实例
WeakReference<Context> weakReference = new WeakReference<>(context);
//获取弱引用保存的引用
Context ctx = weakReference.get();

注意：如果一个对象比较少使用，并且洗碗在使用是随时就获取到，又不想影响次对象的垃圾回收，你可以用WeakReference来标记此对象。

我们来看看单例造成的内存泄漏：

public class InstanceClass {
    private Context mContext;
    private static InstanceClass mInstanceClass;

    public InstanceClass(Context context) {
        this.mContext = context;
    }

    //传入的Context如果外部类(比如Activity)需要销毁时，InstanceClass仍然持有Context，导致Activity无法销毁回收
    public static InstanceClass getInstance(Context context) {
        if (mInstanceClass == null) {
            mInstanceClass = new InstanceClass(context);
        }
        return mInstanceClass;
    }
}

在Activity中使用该实例：

 InstanceClass instanceClass = InstanceClass.getInstance(this);

单例是开发中比较常用的设计模式，但是使用不当也会造成内存泄漏，如上面例子，InstanceClass通过构造方法持有外部类Activity的引用，因为InstanceClass中的实例是static修饰的，所以InstanceClass的声明周期时和应用声明周期一致，如果当外部类销毁的时候，InstanceClass仍然持有Context，导致Activity无法销毁回收，就会导致内存溢出，我们用图形来说明一下：

那么我们可以在InstanceClass构造的时候将Activity的引用存入到弱引用中，需要使用的时候再出来；

public class InstanceClass {
    private Context mContext;
    private static InstanceClass mInstanceClass;

    public InstanceClass(Context context) {
        //构造弱引用实例，将context存入弱引用中
        WeakReference<Context> mWeakReference = new WeakReference<>(context);
        //从弱引用中获取，mWeakReference.get()可能为空，需要做空判断
        this.mContext = mWeakReference.get();
    }

    //传入的Context如果外部类(比如Activity)需要销毁时，InstanceClass仍然持有Context，导致Activity无法销毁回收
    public static InstanceClass getInstance(Context context) {
        if (mInstanceClass == null) {
            mInstanceClass = new InstanceClass(context);
        }
        return mInstanceClass;
    }
}

如果Activity被回收了那么mWeakReference.get()就会返回null，这里需要做空判断。

4.虚引用

虚引用（PhantomReference）是最弱的引用，一个持有虚引用的对象和没有引用几乎是一样的，随时都可能被垃圾回收器回收。通过虚引用的get()方法获取到的引用都会失败(为null)，虚引用必须和引用队列ReferenceQueue一起使用。

ReferenceQueue引用队列作用在于跟踪垃圾回收过程。当垃圾回收器回收对象时，如果发现它还有虚引用，就会在回收后销毁这个对象，并且将虚引用指向的对象加入到引用队列。只能通过虚引用是否被加入到ReferenceQueue来判断虚引用是否为GC回收，这也是判断对象是否为回收的唯一途径。

Java的Object类中有finalize()方法，原理：一旦垃圾回收器准备释放对象占用的内存空间，将首先调用finalize()方法，并且在下一次垃圾回收动作发生时，才会真正回收对象占用的内存，但是问题在于，虚拟机不能保证finalize()何时被调用，因为GC运行时间不是固定的。

使用虚引用就能解决这个问题，虚引用主要用于跟踪垃圾被回收的活动，主要用来实现比较精细的内存使用控制，这对Android来说很有意义，比如我们可以在确定一个Bitmap被回收后，再去申请另个Bitmap的内存，通过这种方式可以使程序消耗的内存维持在一个相对较低较稳定的水平。

//引用队列
ReferenceQueue<Object> queue = new ReferenceQueue<>();
//虚引用
PhantomReference<Object> phantomReference = new PhantomReference<Object>(new Object(), queue);

Log.e(TAG, "虚引用：PhantomReference == " + phantomReference.get());

//系统垃圾回收
System.gc();
System.runFinalization();

Log.e(TAG, "虚引用：PhantomReference == 是否被回收：" + (queue.poll() == phantomReference) + " | 队列中的PhantomReference == " + queue.poll());

phantomReference.get()获取的引用一直为null，调用系统回收垃圾，queue.poll()获取保存的引用对象，并且把它在这个队列中移除，打印log如下：

虚引用无法通过get()方法获取目标的引用，一直都是返回null，可以看源码：

    public T get() {
        return null;
    }

三、回收验证

上面我们验证了虚引用的垃圾回收，我们这次来验证一下强引用、软引用和弱引用的垃圾回收。这里我们使用System.gc()，如果在Android中使用这个API的话，系统只是通知GC，但是什么时候GC我并不知道，所以我们要把例子放在Java的main方法中执行，因为Java和Android的垃圾收集器是不同的，Android不是使用标准的JVM，而是使用Dalvik VM。

1.弱引用垃圾回收验证

在main方法中执行：创建强引用对象，将引用存放到弱引用中，然后手动调用系统gc；

   public static void main(String[] args){
        String str = new String("value");
        WeakReference<String> weakReference = new WeakReference<>(str);
        str = null;
        System.out.println("弱引用：WeakReference == GC回收前：" + weakReference.get());

        //系统GC垃圾回收
        System.gc();

        System.out.println("弱引用：WeakReference == GC回收后：" + weakReference.get());
    }

这里需要str = null; 如果不设置那么结果返回的都是value，为什么呢？因为如果你不将str = null，那么对象str 既持有强引用，也持有弱引用，当然不会被回收；将打印数据如下：

在Andorid中（Activity）中执行上面的代码，那么打印的都是value，因为System.gc()只是通知系统去垃圾回收，没有立即去回收，并不知道它什么时候回收。

点关注，不迷路

好了各位，以上就是这篇文章的全部内容了，能看到这里的人呀，都是人才。

我是suming，感谢各位的支持和认可，您的点赞、评论、收藏【一键三连】就是我创作的最大动力，我们下篇文章见！

如果本篇博客有任何错误，请批评指教，不胜感激 ！

要想成为一个优秀的安卓开发者，这里有必须要掌握的知识架构，一步一步朝着自己的梦想前进！Keep Moving!

源码地址：https://github.com/FollowExcellence/AndroidOptimizeDemo

前言

Java执行GC判断对象是否存活有两种方式其中一种是引用计数。

引用计数：Java堆中每一个对象都有一个引用计数属性，引用每新增1次计数加1，引用每释放1次计数减1。

在JDK 1.2以前的版本中，若一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于(reachable)可达状态，程序才能使用它。

从JDK 1.2版本开始，对象的引用被划分为4种级别，从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

正文

(一) 强引用(StrongReference)

强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。如下：

    Object strongReference = new Object();

当内存空间不足时，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。
如果强引用对象不使用时，需要弱化从而使GC能够回收，如下：

    strongReference = null;

显式地设置strongReference对象为null，或让其超出对象的生命周期范围，则gc认为该对象不存在引用，这时就可以回收这个对象。具体什么时候收集这要取决于GC算法。

    public void test() {
        Object strongReference = new Object();
        // 省略其他操作
    }

在一个方法的内部有一个强引用，这个引用保存在Java栈中，而真正的引用内容(Object)保存在Java堆中。
当这个方法运行完成后，就会退出方法栈，则引用对象的引用数为0，这个对象会被回收。

但是如果这个strongReference是全局变量时，就需要在不用这个对象时赋值为null，因为强引用不会被垃圾回收。

ArrayList的Clear方法：

在ArrayList类中定义了一个elementData数组，在调用clear方法清空数组时，每个数组元素被赋值为null。
不同于elementData=null，强引用仍然存在，避免在后续调用add()等方法添加元素时进行内存的重新分配。
使用如clear()方法内存数组中存放的引用类型进行内存释放特别适用，这样就可以及时释放内存。

(二) 软引用(SoftReference)

如果一个对象只具有软引用，则内存空间充足时，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。

软引用可用来实现内存敏感的高速缓存。

    // 强引用
    String strongReference = new String("abc");
    // 软引用
    String str = new String("abc");
    SoftReference<String> softReference = new SoftReference<String>(str);

软引用可以和一个引用队列(ReferenceQueue)联合使用。如果软引用所引用对象被垃圾回收，JAVA虚拟机就会把这个软引用加入到与之关联的引用队列中。

    ReferenceQueue<String> referenceQueue = new ReferenceQueue<>();
    String str = new String("abc");
    SoftReference<String> softReference = new SoftReference<>(str, referenceQueue);

    str = null;
    // Notify GC
    System.gc();

    System.out.println(softReference.get()); // abc

    Reference<? extends String> reference = referenceQueue.poll();
    System.out.println(reference); //null

注意：软引用对象是在jvm内存不够的时候才会被回收，我们调用System.gc()方法只是起通知作用，JVM什么时候扫描回收对象是JVM自己的状态决定的。就算扫描到软引用对象也不一定会回收它，只有内存不够的时候才会回收。

当内存不足时，JVM首先将软引用中的对象引用置为null，然后通知垃圾回收器进行回收：

    if(JVM内存不足) {
        // 将软引用中的对象引用置为null
        str = null;
        // 通知垃圾回收器进行回收
        System.gc();
    }

也就是说，垃圾收集线程会在虚拟机抛出OutOfMemoryError之前回收软引用对象，而且虚拟机会尽可能优先回收长时间闲置不用的软引用对象。对那些刚构建的或刚使用过的“较新的”软对象会被虚拟机尽可能保留，这就是引入引用队列ReferenceQueue的原因。

应用场景：

浏览器的后退按钮。按后退时，这个后退时显示的网页内容是重新进行请求还是从缓存中取出呢？这就要看具体的实现策略了。

1. 如果一个网页在浏览结束时就进行内容的回收，则按后退查看前面浏览过的页面时，需要重新构建；
2. 如果将浏览过的网页存储到内存中会造成内存的大量浪费，甚至会造成内存溢出。

这时候就可以使用软引用，很好的解决了实际的问题：

    // 获取浏览器对象进行浏览
    Browser browser = new Browser();
    // 从后台程序加载浏览页面
    BrowserPage page = browser.getPage();
    // 将浏览完毕的页面置为软引用
    SoftReference softReference = new SoftReference(page);

    // 回退或者再次浏览此页面时
    if(softReference.get() != null) {
        // 内存充足，还没有被回收器回收，直接获取缓存
        page = softReference.get();
    } else {
        // 内存不足，软引用的对象已经回收
        page = browser.getPage();
        // 重新构建软引用
        softReference = new SoftReference(page);
    }

(三) 弱引用(WeakReference)

弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。

    String str = new String("abc");
    WeakReference<String> weakReference = new WeakReference<>(str);
    str = null;

JVM首先将软引用中的对象引用置为null，然后通知垃圾回收器进行回收：

    str = null;
    System.gc();

注意：如果一个对象是偶尔(很少)的使用，并且希望在使用时随时就能获取到，但又不想影响此对象的垃圾收集，那么你应该用Weak Reference来记住此对象。

下面的代码会让一个弱引用再次变为一个强引用：

    String str = new String("abc");
    WeakReference<String> weakReference = new WeakReference<>(str);
    // 弱引用转强引用
    String strongReference = weakReference.get();

同样，弱引用可以和一个引用队列(ReferenceQueue)联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

简单测试：

GCTarget.java

public class GCTarget {
    // 对象的ID
    public String id;

    // 占用内存空间
    byte[] buffer = new byte[1024];

    public GCTarget(String id) {
        this.id = id;
    }

    protected void finalize() throws Throwable {
        // 执行垃圾回收时打印显示对象ID
        System.out.println("Finalizing GCTarget, id is : " + id);
    }
}

GCTargetWeakReference.java

public class GCTargetWeakReference extends WeakReference<GCTarget> {
    // 弱引用的ID
    public String id;

    public GCTargetWeakReference(GCTarget gcTarget,
              ReferenceQueue<? super GCTarget> queue) {
        super(gcTarget, queue);
        this.id = gcTarget.id;
    }

    protected void finalize() {
        System.out.println("Finalizing GCTargetWeakReference " + id);
    }
}

WeakReferenceTest.java

public class WeakReferenceTest {
    // 弱引用队列
    private final static ReferenceQueue<GCTarget> REFERENCE_QUEUE = new ReferenceQueue<>();

    public static void main(String[] args) {
        LinkedList<GCTargetWeakReference> gcTargetList = new LinkedList<>();

        // 创建弱引用的对象，依次加入链表中
        for (int i = 0; i < 5; i++) {
            GCTarget gcTarget = new GCTarget(String.valueOf(i));
            GCTargetWeakReference weakReference = new GCTargetWeakReference(gcTarget,
                REFERENCE_QUEUE);
            gcTargetList.add(weakReference);

            System.out.println("Just created GCTargetWeakReference obj: " +
                gcTargetList.getLast());
        }

        // 通知GC进行垃圾回收
        System.gc();

        try {
            // 休息几分钟，等待上面的垃圾回收线程运行完成
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 检查关联的引用队列是否为空
        Reference<? extends GCTarget> reference;
        while((reference = REFERENCE_QUEUE.poll()) != null) {
            if(reference instanceof GCTargetWeakReference) {
                System.out.println("In queue, id is: " +
                    ((GCTargetWeakReference) (reference)).id);
            }
        }
    }
}

运行WeakReferenceTest.java，运行结果如下：

可见WeakReference对象的生命周期基本由垃圾回收器决定，一旦垃圾回收线程发现了弱引用对象，在下一次GC过程中就会对其进行回收。

(四) 虚引用(PhantomReference)

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

应用场景：

虚引用主要用来跟踪对象被垃圾回收器回收的活动。
虚引用与软引用和弱引用的一个区别在于：

虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

    String str = new String("abc");
    ReferenceQueue queue = new ReferenceQueue();
    // 创建虚引用，要求必须与一个引用队列关联
    PhantomReference pr = new PhantomReference(str, queue);

程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要进行垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

总结

Java中4种引用的级别和强度由高到低依次为：强引用 -> 软引用 -> 弱引用 -> 虚引用

当垃圾回收器回收时，某些对象会被回收，某些不会被回收。垃圾回收器会从根对象Object来标记存活的对象，然后将某些不可达的对象和一些引用的对象进行回收。

通过表格来说明一下，如下：

引用类型	被垃圾回收时间	用途	生存时间
强引用	从来不会	对象的一般状态	JVM停止运行时终止
软引用	当内存不足时	对象缓存	内存不足时终止
弱引用	正常垃圾回收时	对象缓存	垃圾回收后终止
虚引用	正常垃圾回收时	跟踪对象的垃圾回收	垃圾回收后终止

欢迎关注技术公众号： 零壹技术栈

本帐号将持续分享后端技术干货，包括虚拟机基础，多线程编程，高性能框架，异步、缓存和消息中间件，分布式和微服务，架构学习和进阶等学习资料和文章。