强引用
强引用就是程序中一般使用的引用类型,强引用的对象是可触及的,不会被回收。
- 强引用可以直接访问目标对象
- 强引用所指向的对象在任何时候都不会被系统回收,虚拟机宁愿抛出OOM异常,也不会回收强引用所指的对象
- 强引用可能会导致内存泄漏
软引用
如果一个对象只持有软引用,那么当堆空间不足时,就会被回收。软引用使用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 "[id=" + String.valueOf(id) + ",name=]" + name;
}
}
public static void main(String[] args) {
//user为强引用
User user = new User(1, "changyy");
SoftReference<User> userSoftReference = new SoftReference<>(user);
user = null;
System.out.println(userSoftReference.get());
System.gc();
System.out.println("After GC:");
System.out.println(userSoftReference.get());
byte[] b = new byte[1024 * 900 * 7];
System.gc();
System.out.println(userSoftReference.get());
}
}
使用参数-Xmx10m
[id=1,name=]changyy //第一次从软引用中获取数据
After GC:
[id=1,name=]changyy //GC没有清除软引用
null //由于堆内存不足,软引用被清除
可以得出结论:GC未必会回收软引用的对象,但是当内存资源紧张时,软引用对象会被回收,所以软引用不会导致内存溢出。
每一个软引用都可以附带一个引用队列,当对象的可达性发生改变时(由可达变为不可达),软引用对象就会进入引用队列,通过这个引用队列,可以跟踪对象的回收情况
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 "[id=" + String.valueOf(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 (InterruptedException e) {
e.printStackTrace();
}
if (obj != null) {
System.out.println("user id " + obj.uid + " is delete");
}
}
}
}
}
//自定义一个软引用类,扩展软引用的目的是记录User.uid,后续在引用队列中就可以通过这个uid字段知道哪个User实例被回收了
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,"changyy");
softQueue=new ReferenceQueue<User>();
//创建软引用,指定一个软引用队列,当给定的对象实例回收时,就会加入这个引用队列,通过访问该队列可以追踪到对象的回收情况
UserSoftReference userSoftReference=new UserSoftReference(u,softQueue);
u=null;
System.out.println(userSoftReference.get());
System.gc();
//内存足够 不会被回收
System.out.println("After GC:");
System.out.println(userSoftReference.get());
System.out.println("try to create byte array and GC");
byte[]bytes=new byte[1024*900*7];
System.gc();
System.out.println(userSoftReference.get());
Thread.sleep(1000);
}
}
使用参数-Xmx:10m 运行结果
[id=1,name=]changyy //第一次从软引用获得对象
After GC:
[id=1,name=]changyy //GC后,软引用对象没有回收
try to create byte array and GC //创建数组,耗尽内存
user id 1 is delete //引用队列探测到对象被删除
null //对象已经被回收,无法再通过软引用获取对象
弱引用
弱引用在 系统GC时,只要发现是弱引用,不管系统堆内存使用情况如何,都会将对象进行回收。但是,由于垃圾回收器的线程通常优先级很低,并不一定能很快地发现持有弱引用的对象。在这种情况下,弱引用会存存活很长时间,一旦一个弱引用对象被垃圾回收器回收,便会加入一个注册的引用队列。弱引用使用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=" + String.valueOf(id) + ",name=]" + name;
}
}
public static void main(String[] args) {
User user = new User(1, "changyy");
WeakReference<User> userWeakReference = new WeakReference<>(user);
user = null;
System.out.println(userWeakReference.get());
System.gc();
System.out.println("After GC");
System.out.println(userWeakReference.get());
}
}
[id=1,name=]changyy
After GC
null
可以看到在GC之后 弱引用对象立即被清除
弱引用和软引用一样,可以在构造器引用时,指定一个引用队列,当弱引用对象被回收时,就会加入指定的引用队列,通过这个队列来跟踪对象的回收情况。
注意
软引用、弱引用都非常适合保存那些可有可无的缓存数据,如果这么做,当系统内存不足时,这些缓存数据就会被回收,不会导致内存溢出,而当内存资源充足时,这些缓存数据又可以存在相当长的时间, 从而起到让系统加速的作用。
虚引用
虚引用是所有 引用类型中最弱的一个,一个持有虚引用的对象,和没有引用几乎是一样的,随时都有可能被垃圾回收器回收。当试图通过虚引用的get()方法取得引用时,总是失败。并且虚引用必须和引用队列一起使用,它的作用在于跟踪垃圾回收过程。
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> obj=null;
try {
obj=(PhantomReference<TraceCanReliveObj>)phantomQueue.remove();
} catch (InterruptedException e) {
e.printStackTrace();
}
if (obj!=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> phantomReference=new PhantomReference<>(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 可用
第二次GC
TraceCanReliveObj is delete by GC
obj 是 null