Java中只有传值调用（值传递），没有传址调用（址传递或者引用传递）。所以在java方法中改变参数的值是不会改变原变量的值的，但为什么改变引用变量的属性值却可以呢？请看下面的解答。
 
java中的数据类型
 
Java中数据类型分为两大类：基本类型和引用类型。相应的，变量也分这两种类型：基本类型和引用类型。
 
基本类型的变量保存原始值，即它代表的值就是数值本身；
 
而引用类型的变量保存的值是引用值，"引用值"指向内存空间的地址，代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。
 
基本类型包括：byte,short,int,long,char,float,double,Boolean,returnAddress。
 
引用类型包括：类、接口类型和数组。
 
java中只有值传递
 
在日常编码中，会经常看到如下现象：
 
1、对于基本类型参数，在方法体内对参数进行重新赋值，不会改变原有变量的值。
 
2、对于引用类型参数，在方法体内对参数进行重新赋予引用，不会改变原有变量所持有的引用。
 
3、方法体内对参数进行运算，不会改变原有变量的值。
 
4、对于引用类型参数，方法体内对参数所指向对象的属性进行操作，将改变原有变量所指向对象的属性值。
 
举个例子：
 
public class Main {

    private static void getMiddleOne(boolean b, Boolean boo, Boolean[] arr){

        b = true;

        boo = new Boolean(true);

        arr[0] = true;

    }

       //测试

    public static void main(String[] args) {

        boolean b = false;

        Boolean boo = new Boolean(false);

        Boolean[] arr = new Boolean[]{false};

        getMiddleOne(b, boo, arr);

        System.out.println(b);

        System.out.println(boo.toString());

        System.out.println(arr[0]);

        /**

        * output:

        * false

        * false

        * true

        */

    }

}
 
我们只要了解了下面两点就可以解答上面的现象了：
 
1、基本数据类型的值就是数值本身，所以示例中的b的值就是false；包装类因为会自动装箱拆箱，所以可以和基本类型一样处理，所以示例中boo的值就是false；数组是引用类型，所以arr的值就是指向该Boolean[]的引用。
 
2、java中只有值传递没有引用传递，所以传入getMiddleOne方法的三个参数分别是b的值拷贝, boo的值拷贝, arr的值拷贝。
 
通过上面两点就可以清楚了，getMiddleOne方法中执行的 b=true 和 boo = new Boolean(true) 都是把新值赋给了他们的拷贝，所以不改变原变量的值；同样，arr[0] = true 是把true复制给了arr的拷贝所指向的数组的第一个元素，arr的值和arr的拷贝的值都是该数组的引用，所以arr的拷贝所指向的数组和arr所指向的数组是同一个，所以改变arr的拷贝的数组的元素会同样影响到原变量arr。
 
总结
 
java中只有值传递，基本类型传递的是值的副本，引用类型传递的是引用的副本。
 
 

对一个数据建立一个“引用”，他的作用是为一个变量起一个别名。这是C++对C语言的一个重要补充。
 
如何建立一个引用
 
	int a = 5;
	int &b = a;
	cout<<a<<endl;
	cout<<b<<endl;
	cout<<&a<<endl;
	cout<<&b<<endl;
 
以上声明了b是a的引用，并把a，b的值和它们的地址打印出来。经过声明后b是a别名，b与a代表的是同一个变量，占内存中同一个存储单元，具有同一地址。
 
注意&符号作为取地址符合作为引用声明符的区别，在上述程序中的第2行，&在数据类型后，为引用声明符。而第5、6行，&为取地址符。可以用这个方法作区分：只有在数据类型后&才是引用声明符。
 
打印结果：
 
 
从上述结果可以看到，a与b地址是相同的。
 
使用引用的一些注意事项：
 （1）声明一个引用时，必须同时使之初始化，及声明它代表哪一个变量。（有一个例外，引用作为函数参数时，不需要初始化）
 （2）在声明一个引用后，不能再使之作为另一变量的引用。
 （3）不能建立引用数组。
 
引用的作用：
 
C++加入了在C语言的基础加入了引用机制，那么引用到底有什么用呢？不会只是为了给函数起一个小名吧？显然不是，引用最用要的意义在于作为函数的参数，以扩充函数传递参数的能力。它是如何实现的？这要从C语言参数传递开始说起：
 
我们知道，C语言在调用函数时，传参主要有两种形式：
 （1）变量名作为实参和形参
 这种方式传给形参的是变量的值，传递是单向的。如果在执行函数器件形参的值变了，不会回传给实参。也就是说如果想要实现一个这样的功能：调用函数后实参的值随之改变。显然此方式无法实现。
 
举个例子：
 执行swap函数后，想要主函数内的变量值变化，用上述方式写出代码：
 
#include <iostream>
using namespace std;
int main()
{
      void swap(int ,int);
	  int i =3,j = 5;
	  swap(i,j);
	  cout<<"i="<<i<<endl<<"j="<<j<<endl;
      getchar();
	  return 0;
}

void swap(int a,int b)
{
	int temp;
	temp = a;
	a =b;
	b= temp;
}

 
运行结果：
 i = 3
 j = 5
 
显然值没有带回，i和j的值在执行后没有发生变化。
 
（2）传递变量的地址
 
该方式形参是指针变量，实参是一个变量的地址，调用函数时，形参得到的实参变量的地址，因此指向实参的变量单元。
 然后我们修改下上面的程序：
 
#include <iostream>
using namespace std;
int main()
{
      void swap(int * ,int*);
	  int i =3,j = 5;
	  swap(&i,&j);
	 cout<<"i="<<i<<endl<<"j="<<j<<endl;
      getchar();
	  return 0;
}

void swap(int *a,int *b)
{
	int temp;
	temp = *a;
	*a =*b;
	*b= temp;
}
 
运行结果：
 i = 5
 j = 3
 
在程序的第13行，定义的函数的形参是指针，在第6行，调用的函数是传入的函数实参是变量的地址，实现了i和j的交换，但是这种方法不够直观，而且依旧是“值传递”的方式，只不过传递的是变量的地址而已。
 
然后，如果我们使用引用功能，可以很简单的实现这个功能，而且很容易理解：
 （3）引用作为函数参数
 
#include <iostream>
using namespace std;
int main()
{
      void swap(int & ,int&);
	  int i =3,j = 5;
	  swap(i,j);
	 cout<<"i="<<i<<endl<<"j="<<j<<endl;
      getchar();
	  return 0;
}

void swap(int &a,int &b)
{
	int temp;
	temp = a;
	a =b;
	b= temp;
}

 
运行结果：
 i = 5
 j = 3
 
第13行，形参是声明的引用，注意这个引用并没有初始化，这就是上面提到的特例。而在第7行调用函数的过程中，实现了引用的初始化，这是传入的实参就是变量，而不是数值，所以做到了真正意义上的“变量传递”。

目录
 
一、强引用
 
二、软引用
 
三、弱引用
 
四、虚引用
 
五、总结
 

在JDK1.2以前的版本中，当一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于可触及状态，程序才能使用它。这就像在商店购买了某样物品后，如果有用就一直保留它，否则就把它扔到垃圾箱，由清洁工人收走。一般说来，如果物品已经被扔到垃圾箱，想再把它捡回来使用就不可能了。
 
但有时候情况并不这么简单，可能会遇到可有可无的"鸡肋"物品。这种物品现在已经无用了，保留它会占空间，但是立刻扔掉它也不划算，因为也许将来还会派用场。对于这样的可有可无的物品：如果家里空间足够，就先把它保留在家里，如果家里空间不够，即使把家里所有的垃圾清除，还是无法容纳那些必不可少的生活用品，那么再扔掉这些可有可无的物品。
 
在Java中，虽然不需要程序员手动去管理对象的生命周期，但是如果希望某些对象具备一定的生命周期的话（比如内存不足时JVM就会自动回收某些对象从而避免OutOfMemory的错误）就需要用到软引用和弱引用了。
 
从Java SE2开始，就提供了四种类型的引用：强引用、软引用、弱引用和虚引用。Java中提供这四种引用类型主要有两个目的：第一是可以让程序员通过代码的方式决定某些对象的生命周期；第二是有利于JVM进行垃圾回收。
 
一、强引用
 
之前我们使用的大部分引用实际上都是强引用，这是使用最普遍的引用。比如下面这段代码中的object和str都是强引用：
 
Object object = new Object();
String str = "StrongReference";
 
如果一个对象具有强引用，那就类似于必不可少的物品，不会被垃圾回收器回收。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不回收这种对象。
 
public class StrongReference {
	public static void main(String[] args) {
		new StrongReference().method1();
	}
	public void method1(){
		Object object=new Object();
		Object[] objArr=new Object[Integer.MAX_VALUE];
	}
}
 
运行结果：
 
当运行至Object[] objArr = new Object[Integer.MAX_VALUE]时，如果内存不足，JVM会抛出OOM错误也不会回收object指向的对象。不过要注意的是，当method1运行完之后，object和objArr都已经不存在了，所以它们指向的对象都会被JVM回收。
 
如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。
 
比如ArraryList类的clear方法中就是通过将引用赋值为null来实现清理工作的
 
public void clear() {
      modCount++;

      // Let gc do its work
      for (int i = 0; i < size; i++)
          elementData[i] = null;

      size = 0;
}
 
在ArrayList类中定义了一个私有的变量elementData数组，在调用方法清空数组时可以看到为每个数组内容赋值为null。不同于elementData=null，强引用仍然存在，避免在后续调用 add()等方法添加元素时进行重新的内存分配。使用如clear()方法中释放内存的方法对数组中存放的引用类型特别适用，这样就可以及时释放内存。
 
 
 
二、软引用
 
软引用是用来描述一些有用但并不是必需的对象，在Java中用java.lang.ref.SoftReference类来表示。对于软引用关联着的对象，只有在内存不足的时候JVM才会回收该对象。因此，这一点可以很好地用来解决OOM的问题，并且这个特性很适合用来实现缓存：比如网页缓存、图片缓存等。
 
软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被JVM回收，这个软引用就会被加入到与之关联的引用队列中。
 
import java.lang.ref.SoftReference;

public class SoftRef {  

    public static void main(String[] args){  
        System.out.println("start");            
        Obj obj = new Obj();            
        SoftReference<Obj> sr = new SoftReference<Obj>(obj);  
        obj = null;  
        System.out.println(sr.get());  
        System.out.println("end");     
    }       
}  

class Obj{  
    int[] obj ;  
    public Obj(){  
        obj = new int[1000];  
    }  
}
 
 
当内存足够大时可以把数组存入软引用，取数据时就可从内存里取数据，提高运行效率
 
软引用在实际中有重要的应用，例如浏览器的后退按钮，这个后退时显示的网页内容可以重新进行请求或者从缓存中取出：
 
（1）如果一个网页在浏览结束时就进行内容的回收，则按后退查看前面浏览过的页面时，需要重新构建
 
（2）如果将浏览过的网页存储到内存中会造成内存的大量浪费，甚至会造成内存溢出这时候就可以使用软引用
 
 
 
三、弱引用
 
弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。在java中，用java.lang.ref.WeakReference类来表示。
 
弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。所以被软引用关联的对象只有在内存不足时才会被回收，而被弱引用关联的对象在JVM进行垃圾回收时总会被回收。
 
import java.lang.ref.WeakReference;

public class WeakRef {
    public static void main(String[] args) {
        WeakReference<String> sr = new WeakReference<String>(new String("hello"));
        System.out.println(sr.get());
        System.gc();                //通知JVM的gc进行垃圾回收
        System.out.println(sr.get());
    }
}
 
运行结果：
 
 
在使用软引用和弱引用的时候，我们可以显示地通过System.gc()来通知JVM进行垃圾回收，但是要注意的是，虽然发出了通知，JVM不一定会立刻执行，也就是说这句是无法确保此时JVM一定会进行垃圾回收的。
 
 
 
弱引用还可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
 
Object o = new Object(); //只要o还指向对象就不会被回收
WeakReference<Object> wr = new WeakReference<Object>(o);
 
当要获得weak reference引用的object时, 首先需要判断它是否已经被回收，如果wr.get()方法为空, 那么说明weakCar指向的对象已经被回收了。
 
应用场景：如果一个对象是偶尔的使用，并且希望在使用时随时就能获取到，但又不想影响此对象的垃圾收集，那么应该用 Weak Reference 来记住此对象。或者想引用一个对象，但是这个对象有自己的生命周期，你不想介入这个对象的生命周期，这时候就应该用弱引用，这个引用不会在对象的垃圾回收判断中产生任何附加的影响。
 
 
 
四、虚引用
 
虚引用和前面的软引用、弱引用不同，它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收的活动。
 
虚引用必须和引用队列关联使用，当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
 
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
 
 
public class PhantomRef {
    public static void main(String[] args) {
        ReferenceQueue<String> queue = new ReferenceQueue<String>();
        PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue);
        System.out.println(pr.get());
    }
}
 
 
 
五、总结
 
引用类型
被回收时间
用途
生存时间
强引用
从来不会
对象的一般状态
JVM停止运行时
软引用
内存不足时
对象缓存
内存不足时
弱引用
jvm垃圾回收时
对象缓存
gc运行后
虚引用
未知
未知
未知
在实际程序设计中一般很少使用弱引用与虚引用，使用软引用的情况较多，这是因为软引用可以加速JVM对垃圾内存的回收速度，可以维护系统的运行安全，防止内存溢出（OutOfMemory）等问题的产生
 
 
 
利用软引用和弱引用解决OOM问题：假如有一个应用需要读取大量的本地图片，如果每次读取图片都从硬盘读取，则会严重影响性能，但是如果全部加载到内存当中，又有可能造成内存溢出，此时使用软引用可以解决这个问题。
 
设计思路是：用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题。
 

参考资料：
 
1、https://www.cnblogs.com/dolphin0520/p/3784171.html
 
2、https://blog.csdn.net/junjunba2689/article/details/80601729

前言
 
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的原因。
 
应用场景：
 
浏览器的后退按钮。按后退时，这个后退时显示的网页内容是重新进行请求还是从缓存中取出呢？这就要看具体的实现策略了。
 
如果一个网页在浏览结束时就进行内容的回收，则按后退查看前面浏览过的页面时，需要重新构建；
如果将浏览过的网页存储到内存中会造成内存的大量浪费，甚至会造成内存溢出。
 
这时候就可以使用软引用，很好的解决了实际的问题：
 
    // 获取浏览器对象进行浏览
    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停止运行时终止
软引用
当内存不足时
对象缓存
内存不足时终止
弱引用
正常垃圾回收时
对象缓存
垃圾回收后终止
虚引用
正常垃圾回收时
跟踪对象的垃圾回收
垃圾回收后终止
 
 
欢迎关注技术公众号： 零壹技术栈
 
 
本帐号将持续分享后端技术干货，包括虚拟机基础，多线程编程，高性能框架，异步、缓存和消息中间件，分布式和微服务，架构学习和进阶等学习资料和文章。