Java中的引用类型总结

在java的引用体系中有4种引用类型：强引用、软引用、弱引用和虚引用。Java中提供这四种引用类型主要有两个目的：一个是可以让程序员通过代码的方式决定某些对象的生命周期；另一个是有利于JVM进行垃圾回收。四种类型对象特征如下：

引用类型	被垃圾回收时间	用途	生存时间
强引用	从来不会回收	对象的一般状态	JVM停止运行时终止
软引用	当内存不足时被回收	对象缓存	内存不足时终止
弱引用	正常GC时被回收	对象缓存	垃圾回收后终止
虚引用	正常GC时被回收	跟踪对象的垃圾回收	垃圾回收后终止

#Java执行GC判断对象是否存活有两种方式：引用计数、GC Roots可达性分析法。
（1）引用计数法：每个对象有一个引用计数属性，新增一个引用时计数加1，引用释放时计数减1，计数为0时可以回收。

（2）可达性分析法：从GC Roots开始向下搜索，搜索所走过的路径称为引用链。当一个对象到GC Roots没有任何引用链相连时，则证明此对象是不可用的，那么虚拟机就判断是可回收对象。(作为GC Roots的位置:系统类加载器(System Class Loader)加载的对象、正在被用于同步的各种锁对象、活着的线程栈帧中的引用的对象等)

#从JDK 1.2版本开始，对象的引用被划分为4种级别，从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

1.强引用

强引用(StrongReference)是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。强引用是平时开发使用得最最普遍的引用。例如下面这种写法：

Object object = new Object();
String str = "1231321";

当内存空间不足时，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。

#(1)方法内部的强引用
@Test
public void strongReference(){
	Object object = new Object();
	String str = "1231321";
	//其他操作
}
#如上例子：方法中的这部分强引用保存在Java栈中，而真正的引用内容(Object)保存在Java堆中。当这个方法运行完成后，就会退出方法栈，则引用对象object、str的引用数为0，这个对象会被回收。

#(2)全局变量的强引用
public class ObjectReferenceDemo {
    private Object object = new Object(); //全局变量的强引用
    private String str = "1231321";  //全局变量的强引用
    @Test
    public void strongReference() {
        System.out.println(object.toString());
        System.out.println(str);
		object = null;
		str = null;
    }
}
#如上例子: 如果这个object、str是全局变量时，就需要在不用这个对象时赋值为null，对象才能被GC回收，因为强引用不会被垃圾回收。

如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。比如ArrayList的Clear方法就是这样操作的。

public void clear() {
	modCount++;
	// clear to let GC do its work
	for (int i = 0; i < size; i++)
		elementData[i] = null;
	size = 0;
}

#在ArrayList类中定义了一个私有的变量elementData[Object]数组，在调用方法清空数组时是将每个数组内元素赋值为null。如果用elementData=null数组类的元素强引用仍然存在(比如数组内元素A还在其他地方使用)，续调用add()等方法添加元素时会重新的内存分配。

2.软引用

如果一个对象只具有软引用(SoftReference)，则内存空间充足时，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。这一点可以很好地用来解决OOM的问题，并且这个特性很适合用来实现高速缓存：比如网页缓存、图片缓存等。

#(1)强引用问题：如下对象RefA内引用了对象obj。
    Object obj = new Object();
    RefA ref = new RefA(obj);

#在这种情况下，如果refA没有被GC，那么obj这个对象肯定不会GC的，因为refA引用到了obj。如果obj是一个大对象或多个这种对象的话，应用肯定一会就挂掉。那么，如果我们希望在这样一个体系中：
#如果obj没有被其它对象引用，只是在这个RefA中存在引用时，就把obj对象gc掉。这时候就可以使用Reference对象了。

#(2)软引用：当内存不足时，即使obj在其它地方还在使用，都会被回收
A obj = new A();
SoftReference<A> reference = new SoftReference<A>(str);

另外软引用可以和一个引用队列(ReferenceQueue)联合使用。如果软引用SoftReference所引用对象(如上面的obj对象)被垃圾回收，JAVA虚拟机就会把这个软引用(如上面的reference对象)加入到与之关联的引用队列中。软引用对象reference内的引用的对象obj是被GC回收了的，所以在使用reference.get()获取对象时为null。

@Test
public void softReference() throws InterruptedException {
	ReferenceQueue<byte[]> referenceQueue = new ReferenceQueue<>();
	Object value = new Object();
	Map<Object, Object> map = new HashMap<>();
	for(int i = 0;i < 100;i++) {
		byte[] bytes = new byte[1024*1024*1024];
		SoftReference<byte[]> reference = new SoftReference<byte[]>(bytes, referenceQueue);
		map.put(reference, value);
	}
	System.out.println("map-size: " + map.size());

	int cnt = 0;
	SoftReference<byte[]> k;
	//当内存不足时，bytes数组会被回收一部分
	while((k = (SoftReference) referenceQueue.poll()) != null) {
		System.out.println((cnt++) + "bytes数组被回收了:" + k.get());
	}
}

#注意：运行时加上-XX:+PrintGCDetails参数，打印GC信息便于观察。输出如下,只有部分bytes[]对象被回收了，原因在于软引用是在内存空间不足时，才会回收这些对象的内存。

#输出内容如下
.................
.................
[GC (Allocation Failure) --[PSYoungGen: 1048576K->1048576K(1244672K)],0.0376789 secs]
[Full GC (Allocation Failure) [PSYoungGen: 1048576K->0K(1244672K)],0.5596495 secs]
map-size: 100
0bytes数组被回收了:null
1bytes数组被回收了:null
2bytes数组被回收了:null
...................
90bytes数组被回收了:null
91bytes数组被回收了:null
92bytes数组被回收了:null
93bytes数组被回收了:null

当内存不足时，JVM首先将软引用中的对象引用置为null，然后通知垃圾回收器进行回收，也就是说圾收集线程会在虚拟机抛出OutOfMemoryError之前回收软引用对象，而且虚拟机会尽可能优先回收长时间闲置不用的软引用对象。对那些刚构建的或刚使用过的“较新的”软对象会被虚拟机尽可能保留，这就是引入引用队列ReferenceQueue的原因。

if(JVM内存不足) {
    // 将软引用中的对象引用置为null
    str = null;
    // 通知垃圾回收器进行回收
    System.gc();
}

3.弱引用

弱引用(WeakReference)也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。在java中用java.lang.ref.WeakReference类来表示。

弱引用与软引用的区别在于：弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象(没有任何强引用关联他)，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。所有被软引用关联的对象只有在内存不足时才会被回收，而被弱引用关联的对象在JVM进行垃圾回收时总会被回收。

@Test
public void weakReference() throws InterruptedException {
	WeakReference<String> weakReference = new WeakReference<>(new String("1234"));
	System.out.println(weakReference.get());
	System.gc();
	Thread.sleep(500);
	#弱引用weakReference中引用的"1234"对象，在GC时就会被回收掉
	System.out.println(weakReference.get());
	
	System.out.println("======================");
	
	SoftReference<String> softReference = new SoftReference<>(new String("1234"));
	System.out.println(softReference.get());
	System.gc();
	Thread.sleep(500);
	#软引用softReference中引用的"1234"对象，在GC时不会被回收(只有在内存不足时会被回收)。
	System.out.println(softReference.get());
}

#输出：
1234
null
======================
1234
1234

#注意：在使用软引用和弱引用的测试时，可以显示地通过System.gc()来通知JVM进行垃圾回收，但是要注意的是，虽然发出了通知，JVM不一定会立刻执行，也就是说这句是无法确保此时JVM一定会进行垃圾回收的。

同样，弱引用可以和一个引用队列(ReferenceQueue)联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

@Test
public void weakReference() throws InterruptedException {
	ReferenceQueue<String> referenceQueue = new ReferenceQueue();
	WeakReference<String> weakReference = new WeakReference<>(new String("1234"), referenceQueue);
	System.out.println(weakReference.get());
	System.gc();
	Thread.sleep(500);
	System.out.println(weakReference.get());
	Reference<? extends String> reference = referenceQueue.poll();
	System.out.println("弱引用对象：" + reference);
	System.out.println("弱引用对象引用的对象：" + reference.get());
}

#输出内容：
    1234
    null
    弱引用对象：java.lang.ref.WeakReference@ed17bee
    弱引用对象引用的对象：null

4.虚引用

虚引用和前面的软引用、弱引用不同，它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收器回收的活动。

#虚引用与软引用和弱引用的一个区别在于
	虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

@Test
public void phantomReference(){
	ReferenceQueue<String> referenceQueue = new ReferenceQueue();
	PhantomReference<String> phantomReference = new PhantomReference<>(new String("1234"), referenceQueue);
	//输出null
	System.out.println(phantomReference.get());
}

总结：利用软引用和弱引用解决OOM问题，假如有一个应用需要读取大量的本地图片，如果每次读取图片都从硬盘读取，则会严重影响性能，但是如果全部加载到内存当中，又有可能造成内存溢出，此时使用软引用可以解决这个问题。

#设计思路是
	用一个HashMap的key来保存图片的路径，value保存图片对象关联的软引用对象(softReference)，在内
存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题。或直接使用WeakHashMap来解决这个缓存问题。

 

                                                                                                       2020年09月20日  晚  于北京记