GC 的基本思想是考察每个对象的可触及性（可达性），就是从GC Root开始是否可以访问到这个对象。如果可以，则可达，否则就是不可达。在 Java 中，可作为GC Roots的对象包括：

• JVM栈（栈中的本地变量表）中的引用的对象
• 方法去中类静态属性引用的对象
• 方法区中常量引用的对象
• 本地方法栈中JNI（Native方法）引用的对象

对于可触及性，可以包含以下3种状态。

• 可触及的：从根节点开始，可以到达这个对象。
• 可复活的：对象的所有引用都被释放，但是对象有可能在finalize()函数中复活
• 不可触及的：对象的finalize()方法别调用过，并且没有被复活（finalize()方法只会被调用一次）

Java中提供了4个级别的引用：强引用、软引用、弱引用和虚引用。

强引用

强引用是程序中一般使用的引用类型。强引用的对象是可触及的、不可被回收的。例如：

StringBuffer str = new StringBuffer("Hugege");
StringBuffer str1 = str;
 

上述代码内存示意图如下：

强引用内存示意图

​​​​​​​强引用包含以下特点：

• 可以直接访问目标对象
• 所指向的对象在恩和时候都不会被系统回收，JVM宁愿抛出OOM，也不会回收对象
• 可能导致内存泄漏

软引用

软引用是比强引用弱一点的引用类型。一个对象如果只持有软引用，那么当堆空间不足时，就会被回收（由 SoftReference 实现）。代码如下：

/**
 * 软引用在系统堆内存不足是，被回收
 * 
 * VM Args: -Xmx10M
 * 
 * @author xuefeihu
 *
 */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, "xuefeihu");
SoftReference<User> userSoftRef = new SoftReference<User>(u);
u = null;
System.out.println(userSoftRef.get());
System.gc();
System.out.println("After GC: ");
System.out.println(userSoftRef.get());
byte[] b = new byte[1024 * 985 * 7]; // 这里与JDK的版本有关（笔者JDK8），过小不会回收，过大会OOM
System.gc();
System.out.println(userSoftRef.get());
}
}
 

增加上述GC参数，运行结果如下：

User [id=1, name=xuefeihu]
After GC: //内存充足时GC
User [id=1, name=xuefeihu]
null //内存不足是GC，数据已被清除
 

综上，GC未必会回收软引用的对象，但是当内存不足时，软引用对象就会被回收，因此软引用对象不会引起内存溢出。

引用队列

每个软引用都可以附带一个引用队列，当对象的可达性状态发生变化时（由可达变为不可达），软引用对象就会进入引用队列。通过这个队列，可以追踪对象的回收情况。代码如下：

/**
 * 每个软引用都可以附带一个引用队列，当对象的可达性状态发生变化时（由可达变为不可达），
 * 软引用对象就会进入引用队列。通过这个队列，可以追踪对象的回收情况。
 * 
 * VM Args: -Xmx10M
 * 
 * @author xuefeihu
 *
 */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 "User [id=" + 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 (Exception e) {
e.printStackTrace();
}
if (obj != null) {
System.out.println("user id = " + obj.uid + " is delete");
}
}
}
}
}
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, "xuefeihu");
softQueue = new ReferenceQueue<User>();
UserSoftReference userSoftRef = new UserSoftReference(u, softQueue);
u = null;
System.out.println(userSoftRef.get());
System.gc();
// 内存足够，不会被回收
System.out.println("After GC :");
System.out.println(userSoftRef.get());
System.out.println("try to create byte array and GC");
byte[] b = new byte[1024 * 985 * 7];
System.gc();
System.out.println(userSoftRef.get());
Thread.sleep(1000);
}
}
 

使用上述VM参数，执行结果如下：

User [id=1, name=xuefeihu] 
After GC :
User [id=1, name=xuefeihu] //内存充足时，GC结果
try to create byte array and GC //内存不足时GC
user id = 1 is delete //引用队列探测到对象被删除
null //对象已回收
 

弱引用

弱引用是一种比软引用还弱的一种引用。GC时只要发现，就会对其进行回收。一旦被回收时，就会加入到一个引用队列中（和软引用很像），Java中使用WeakReference实现。demo如下：

/**
 * 弱引用在GC时就会被回收
 * 
 * @author xuefeihu
 *
 */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 "User [id=" + id + ", name=" + name + "]";
}
}
public static void main(String[] args) {
User u = new User(1, "xuefeihu");
WeakReference<User> userWeakRef = new WeakReference<User>(u);
u = null;
System.out.println(userWeakRef.get());
System.gc();
// 不管当前内存空间足够与否，都会回收它的内存
System.out.println("After GC: ");
System.out.println(userWeakRef.get());
}
}
 

上述代码运行结果如下：

User [id=1, name=xuefeihu]
After GC: 
null
 

从结果看来，不论内存状况，每次GC都会清除弱引用的对象。

虚引用（幽灵引用）

虚引用是所有引用中最弱的一个。持有虚引用的对象，和没有引用几乎一样，随时都有可能被回收，因此也叫幽灵引用。当使用虚引用的get()方法获得强引用时，总是失败的。虚引用必须和引用队列一起使用，作用于跟踪垃圾回收过程。

下面示例使用虚引用跟踪一个可复活对象的回收。

/**
 * 使用虚引用跟踪一个可复活对象的回收
 * 
 * 当GC回收对象时，如果发现有虚引用，就会将其放入引用队列
 * 虚引用必须和引用队列一起使用，它的作用在于跟踪垃圾回收过程。
 * 
 * @author xuefeihu
 *
 */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> objt = null;
try {
objt = (PhantomReference<TraceCanReliveObj>) phantomQueue.remove();
} catch (Exception e) {
e.printStackTrace();
}
if(objt != 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> phantomRef = new PhantomReference<TraceCanReliveObj>(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 可用
第2次GC //对象无法复活
TraceCanReliveObj is delete by GC //引用队列捕获到对象被回收
obj 是 null
 

参考：《实战Java虚拟机》