一、四大引用级别的概念
- 强引用：就是正常的引用，类似于下面：
-
Object object = new Object();,object就是一个强引用，gc是不会清理一个强引用引用的对象的，即使面临内存溢出的情况。
- 软引用：SoftReference，GC会在内存不足的时候清理引用的对象：
SoftReference reference = new SoftReference(object); object = null;
- 弱引用：GC线程会直接清理弱引用对象，不管内存是否够用：
WeakReference reference = new WeakReference(object); object = null;
- 虚引用：和弱引用一样，会直接被GC清理，而且通过虚引用的get方法不会得到对象的引用，形同虚设，这里弱引用是可以的：
PhantomReference refernce = new PhantomReference(object); object = null;
二、四大引用级别之间的区别
强引用和软引用
- 这个比较简单，软引用只有在内存不足的时候才会被清理，而强引用什么时候都不会被清理（程序正常运行的情况下），即使是内存不足，利用这一个特性，可以做一些缓存的工作，下面的应用会讲到。
软引用和弱引用
- 弱引用不会影响GC的清理，也就是说当GC检测到一个对象存在弱引用也会直接标记为可清理对象，而软引用只有在内存告罄的时候才会被清理
弱引用和虚引用
- 说这个之前要说一下ReferenceQueue的概念，ReferenceQueue是一个队列，初始化Reference的时候可以作为构造函数的参数传进去，这样在该Reference的referent域（Reference用来保存引用对象的属性）指向的引用对象发生了可达性的变化时会将该Reference加入关联的队列中，这个具体的变化根据Reference的不同而不同。官方APi对ReferenceQueue的介绍：
Reference queues, to which registered reference objects are appended by the garbage collector after the appropriate reachability changes are detected.- 简单翻译就是：当reference object所引用的对象发生了适当的可达性变化时，GC向该队列追加该引用对象（reference object）。
- 弱引用和虚引用的区别就在于被加入队列的条件不同，这里主要侧重于考虑对象所属的类重写了finalize方法，将对象的状态归纳为三种：finalizable, finalized、reclaimed，分别代表：未执行finalize函数、已经执行finalize函数，已经回收。如果没有重写finalize函数的话下面再考虑。
- 虚引用必须和一个ReferenceQueue联合使用，当GC准备回收一个对象的时候，如果发现该对象还有一个虚引用，就会将这个虚引用加入到与之关联的队列.
- 弱引用：当GC第一次试图回收该引用指向的对象时会执行该对象的finalize方法，然后将该引用加入队列中，但是该引用指向的对象是可以在finlize函数中“复活”的，所以即使通过Reference的get方法得到的是null，而且reference被加入到了ReferenceQueue，这个对象仍然是存活的，这种现象是有点违背对象正常生命周期的，下面以代码示例：
package com;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
public class Main {
static Weak weak;
static class Weak {
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("finalize() is called");
weak = this;//复活对象
System.out.println("after finalize ,object is alive again");
}
}
public static void main(String[] args) throws InterruptedException {
weak = new Weak();
ReferenceQueue queue = new ReferenceQueue<>();
WeakReference<Weak> weakReference = new WeakReference<Weak>(weak, queue);
// PhantomReference<Weak> weakReference = new PhantomReference<>(weak,queue);
if (weakReference.get() == null) {
System.out.println("before gc : reference is not available");
} else {
System.out.println("before gc : reference is available");
}
weak = null;
System.gc();//执行GC线程
Thread.sleep(3000);
if (weakReference.get() == null) {
System.out.println("after gc : reference is not available");
} else {
System.out.println("after gc : reference is available");
}
if (queue.poll() == null) {
System.out.println("after gc : reference is not in queue");
} else {
System.out.println("after gc : reference is in queue");
}
weak=null;
System.gc();//再次执行GC
Thread.sleep(3000);
if (queue.poll() == null) {
System.out.println("gc agaain : reference is not in queue");
} else {
System.out.println("gc agaain : reference is in queue");
}
}
}
- output：
before gc : reference is available
finalize() is called
after finalize ,object is alive again
after gc : reference is not available
after gc : reference is in queue
gc agaain : reference is not in queue
- 可以看到，对象在复活之后，reference不可用，而且reference已经被加入到队列中。
- 虚引用：虚引用只有在对象处于reclaimed状态时才会将相关reference加入到队列，可以根据这个特性检测对象准确的生命周期，比如可以知道对象精确的销毁时间。
- 和上面相同的代码，输出如下：
before gc : reference is not available
finalize() is called
after finalize ,object is alive again
after gc : reference is not available
after gc : reference is not in queue
gc again : reference is in queue
- 我们可以根据输出看到明显的区别：
- 弱引用可以得到对象的引用，而虚引用不可以
- 弱引用在第一次被GC清理的时候会调用finalize方法，然后将reference加入到队列，即使这时候的对象是存货状态，而虚引用在第二次GC执行，对象处于reclaimed状态时才会将reference加入到队列。
- 顺便提一下软引用，在这个方面，软引用和弱引用是一样的，也就是说即使加入到了队列中，也不能确定对象是否销毁。
三、四大引用的应用
软引用
- 缓存敏感数据
- 适用情景:一个web应用，查询联系人数据，如果在浏览的过程中点击了返回上一条查询结果，正常处理就是再重新查询一次，然而这样是很浪费时间的，所以如果能将上一次的查询结果缓存下来就会极大的提升性能，所以可以将查询结果保存为软引用，这样在内存充足的情况下GC都不会释放掉这个引用指向的对象，下次需要结果的时候可以先判断一下这个对象是否被释放，如果没有就可以直接利用不用再次查询。
- 当软引用所指向的对象被回收的时候，通过get方法返回的是null，如果在构造软引用的时候传入了一个ReferenceQueue，就是将这个reference加入到队列，然后我们可以清理这些无用的reference。实际上我们最好这样做，否则会造成大量无用reference导致的内存泄漏。
- 下面举一个缓存的例子:
package com;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.HashMap;
public class Main {
}
class People{
String id;
String name;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class PeopleCache {
private static PeopleCache singlonCache;
private HashMap<String, PeoReference> refChache;//用来存储缓存的数据
private ReferenceQueue queue;
//自定义引用类，增加属性_key,方便在缓存数据中查找
static class PeoReference extends SoftReference {
private String _key;
public PeoReference(People referent, ReferenceQueue q) {
super(referent, q);
_key = referent.getId();
}
}
private PeopleCache(){
this.queue=new ReferenceQueue();
this.refChache=new HashMap<>();
}
public static PeopleCache getInstance(){
if(singlonCache==null){
singlonCache=new PeopleCache();
}
return singlonCache;
}
public void cachePeople(People people){
cleanCache();//清除已经标记为垃圾的引用
PeoReference reference = new PeoReference(people, queue);
refChache.put(people.getId(), reference);//将对象的软引用保存到缓存中
}
public void cleanCache(){
PeoReference reference = null;
while ((reference = (PeoReference)queue.poll())!=null){
refChache.remove(reference._key);
}
}
public People getCachedPeople(String key){
People people = null;
if (refChache.containsKey(key)){
people= (People) refChache.get(key).get();
System.out.println("get object from cache");
}else{
people = new People();
System.out.println("get object from database or web server");
}
return people;
}
}
- 当需要查询数据的时候先获取一个PeopleCache实例，然后使用getCachedPeople方法试图去获取指定ID的数据，如果缓存中有的话就从缓存中获取，没有的话就正常查询获取，并且将查询结果缓存到HashMap。
弱引用
- WeakHashMap
- 具体使用和HashMap一样，但是它的键存放的是对象的弱引用，如果该弱引用指向的对象被垃圾回收了，WeakHashMap就会删除对应的数据（键值对）。
- 用来缓存那些非必需存在的数据。
虚引用
