在说四大引用之前,我们需要弄明白一个问题:什么是引用?
什么是引用?引用的本质是指针常量,对于我们这篇文章来说,我们只需要知道引用是一种特殊的指针就行了。
下面是Java中典型的声明和创建对象的代码,其中o就是我们的引用。前面的Object是引用类型,后面的new Object()是Java对象。o指向了new Object(),也就是o引用了new Object()对象。
Object o=new Object();
我们可以用下图描述这个概念,o引用了new Object()对象。而且这种引用是强引用。也就是说,我们常写这种new对象的方式都是强引用方式。那么什么是强引用?为什么叫强引用?
强引用“强”在哪里?如果我们不手动将引用设置为null,gc是不会回收强引用的,即使内存不够也不会回收被强引用的对象,这时候会抛OOM异常。这样的好处是对象更加“稳定”,只要应用还在运行,强引用对象可以一直存活。想象一下如果你刚创建的对象还没执行完他的任务就因为内存不够而被gc回收了,这是多么可怕的场景。强引用也会带来问题,那就是可能造成内存泄漏。后面会继续介绍内存泄漏的细节。
如果我们手动的将强引用设置为null,那么gc就会认为不存在引用,就会回收。
在Java的Object类有一个finalize方法,当对象被gc回收的时候,会调用这个方法。可以利用这个方法来观察对象是否被gc回收。
public class M {
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("finalize");
}
}
public class TestFinalize {
public static void main(String[] args) throws IOException {
M m=new M();
m=null;
System.gc();
//gc回收需要时间,保险起见,让程序一直等待,不写也是能看到效果的。
System.in.read();
}
}
输出:
finalize
但m被设置为null的时候,gc确实能回收我们的对象。
软引用(SoftReference)事实上引用类型可以按引用强度来划分,软引用就是相对强引用弱一点的引用。
Java将软引用封装为SoftReference类。软引用的特点是当内存不够的时候,gc会回收软引用的对象。这样就不容易造成OOM。下面的代码就是一个软引用的例子。我们new了一个10M大小的数组。并且用SoftReference包装,用这么大的数组是为了模拟OOM,后面会用到。
SoftReferencesr=new SoftReference<>(new byte[10*1024*1024]);
现在我们先看下软引用的结构。如下图所示,注意sr这个引用是强引用,内部会执行类似下面的代码,这里的byteArr变量也是强引用。软引用指的是下图虚线的部分,也就是SoftReference内部有个指向我们new的数组的指针。如下图SR ref才是我们的软引用。至于SR ref为什么能够实现软引用的功能,这个是JVM的事情,我们不需要关心。
byte[] byteArr=new byte[10*1024*1024]
下面的例子模拟内存不足的时候gc会回收软引用对象。可以通过下面的JVM参数将内存大小设置为20M。在IDEA里面可以这样设置。
前两次调用get方法的时候都能够获取到对象,因为这时候内存足够,当我们执行byte[] b=new byte[1010241024]这行代码的时候,又创建了一个10M的数组,加上虚拟机本身也会占用一些内存,所以这时候已经内存溢出了,但没有报OOM异常,因为虚拟机执行gc发现有软引用,就把软引用的10M对象给回收了,这样内存就又够用了,但执行第三个get方法的时候返回null,因为软引用对象已经被gc回收。这时候我们又创建了一个10M的数组byte[] b2=new byte[1010241024]。这时候存在两个强引用类型的数组,总大小为20M加上虚拟机自身占用的内存,直接导致OOM异常。
public static void main(String[] args) throws IOException, InterruptedException {
SoftReference sr=new SoftReference<>(new byte[10*1024*1024]);
System.out.println(sr.get());
System.gc();
Thread.sleep(500);
System.out.println(sr.get());
byte[] b=new byte[10*1024*1024];
System.out.println(sr.get());
byte[] b2=new byte[10*1024*1024];
System.in.read();
}
输出:
[B@135fbaa4 [B@135fbaa4 null Exception in thread "main" java.lang.OutOfMemoryError: Java heap space at ref.TestSoftRef.main(TestSoftRef.java:15)弱引用
弱引用的强度就更弱了。只要对象被弱引用包裹,不管内存够不够,gc只要发现有弱引用,马上回收。Java中用WeakReference类表示弱引用。下面的代码,并没有内存不足的情况,只要gc执行了,弱引用马上就会被回收。
WeakReferencewr=new WeakReference<>(new M()); System.out.println(wr.get()); System.gc(); Thread.sleep(10); System.out.println(wr.get());
gc执行,弱引用被回收,finalize方法被调用,再次调用get方法,返回null。
输出:
ref.M@135fbaa4 finalize null
为了加深理解,再举下面的例子。
下面的代码可能造成内存泄漏,很可能习惯性的就写成这样,但这样写是不好的。
public class A {
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("A finalize");
}
}
WeakReference wr = new WeakReference<>(new A()); //a强引用wr value A a = wr.get(); //输出a System.out.println(a); System.gc(); Thread.sleep(100); System.out.println(wr.get());
输出:
ref.A@135fbaa4 ref.A@135fbaa4
我们发现弱引用里面的对象没有被回收。
我们调用get方法获取弱引用所指向的对象new A(),并用变量a引用,这时候a变量是直接强引用了new A()。因为被强引用,即使wr.get被WeakReference包装,也不会被回收,除非你手动把a设为null。如下图所示,new A()对象实际上有两个引用指向,一个是WeakReference内部的弱引用,一个是变量a的强引用,因为有强引用,所以new A()是不会被gc回收的。
在上面的代码末尾加上下面的代码,就可以回收弱引用包裹的对象了。
a = null;
System.gc();
//输出a
System.out.println(wr.get());
ref.A@135fbaa4 ref.A@135fbaa4 null A finalize
弱引用并不一定容易回收,如果被别的引用强引用的话。
这个例子给我们的另一个启发是,如果你遇到比较复杂的情况,这样试着画图理清关系。
下面再举一个更复杂的例子加深理解。
这个例子非常的重要,可以深入理解弱引用和Java内存模型。
有两个类A,B。在A的构造器里面创建B对象,并在A类内部有引用b引用了new B()对象。finalize里面做了些延时操作和输出,后面会解释这些操作的细节。
public class A {
private B b;
public A() {
b=new B();
}
public B getB() {
return b;
}
@Override
protected void finalize() throws Throwable {
super.finalize();
//如果休眠太长,后面的代码可能不会输出
Thread.sleep(500);
System.out.println("b in finalize "+b);
System.out.println("A finalize");
}
}
public class B {
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("B finalize");
}
}
示例主要目的是观察gc回收前后对象的变化。
WeakReference wr = new WeakReference<>(new A()); A a = wr.get(); //输出a System.out.println(a); B b=a.getB(); //输出b System.out.println(b); System.gc(); Thread.sleep(500); System.out.println("-------gc 执行后------"); System.out.println(a); System.out.println(b); // a=null; System.gc(); System.out.println("-------a=null 并执行gc------"); Thread.sleep(500); System.out.println(a); System.out.println(b);
输出:
ref.A@135fbaa4 ref.B@45ee12a7 -------gc 执行后------ ref.A@135fbaa4 ref.B@45ee12a7 -------a=null 并执行gc------ null ref.B@45ee12a7 b in finalize ref.B@45ee12a7 A finalize
**重要的来了。**上面的例子可能光看代码太抽象了,可以看图,这里的核心就是a引用,A类内部的b引用和main方法里面的b引用。new A()对象有两个引用一个是WeakReference提供的软引用,另一个是a引用。如果我们没有手动将a设为空,new A()对象是不会被gc回收的。这个和前面举的例子一样,还是好理解的。现在情况变的复杂了,A类的构造器里面new了一个 new B()对象。
第一个问题:new A()和new B()是什么关系?是不是嵌套关系?
下图之所以这样画,就是因为new A()和new B()并没有嵌套关系。他们都是堆内存中平行的对象而已。
第二个问题:如果new A()被gc回收,new B()会不会因为new A()被回收而回收?
下面这段话非常重要,多读几遍可以深刻理解弱引用和内存模型的关系。
下面这段话非常重要,多读几遍可以深刻理解弱引用和内存模型的关系。
下面这段话非常重要,多读几遍可以深刻理解弱引用和内存模型的关系。
和第一个问题一样,new A()回收关我new B()什么事?虽然A类内部有个b变量引用了new B(),但这个是属于A类的事情,和new A()对象是两回事。注意,这里一定要明白的一个概念是new A和A类是完全两回事,A类声明的这些引用变量是在内存的方法区的,A类和这些引用只有程序结束的时候才会销毁,但new出来的对象有可能在任意时间销毁。new B()和new A()是没什么关系的,但new B()和A类是有关系的,因为A类有个b变量引用new B()。
第三个问题:finalize方法什么时候被调用?
finalize方法是在gc回收前被调用的,也就是gc已经准备回收对象,并且这个对象已经是可回收的,finalize方法就是用来做gc前的善后工作的。或许可以换个名字叫beforeGC()。上面的代码我故意在finalize方法里面休眠了500ms,如果休眠的时间变长,finalize方法可能不会被调用。因为目标对象已经被回收了,休眠后面的代码将不会执行。所以finalize方法是不可靠的,不要做耗时的工作,但把休眠代码写在最后,前面的代码还是可以正常输出的。
在弄明白这三个问题之后,上面的代码执行的结果就非常的好理解。a置为null,所以gc的时候,new A()被回收,内部b输出是有内容的,因为new A()虽然被回收了,但A类及包括的引用都在方法区存在,所以new B()对象是同时被A类内部的b变量和main方法里面的b变量同时引用的,只有这两个引用同时置成null,new B()对象才会被gc回收。
虚引用在Java中用PhantomReference类表示。属于最弱的一种引用,gc随时可以回收虚引用。看起来和弱引用很像。不过我们基本不需要关系这个引用。虚引用对于一般的应用开发来说是用不到的。对于开发者来说,最重要的是弱引用。



