Java中的引用类型总结

╰+攻爆jí腚メ 2022-12-08 15:50 131阅读 0赞

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

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

#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日 晚 于北京记