135-1821-9792

Java 中的四种引用

之前我们提到过 GC，但当 Java 中引用的对象越来越多，会导致内存空间不足，最终会产生错误 OutOfMemoryError，并让应用程序终止。那为什么 GC 在此时不能多收集一些对象呢?这就和今天说的引用类型有关了。

和龙ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为创新互联公司的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：028-86922220（备注：SSL证书合作）期待与您的合作！

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

强引用

强引用(Strong Reference)是使用最普遍的引用。如果一个对象具有强引用，那么它永远不会被 GC。例如：

 
 
 
      
  
  
  1. Object strongReference = new Object(); 
    2.

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

如果强引用对象不使用时，需要弱化从而可以被 GC，例如ArrayList中的clear()方法：

 
 
 
      
  
  
  1. /** 
    2.   
  
  
  2. * Removes all of the elements from this list. The list will 
    3.   
  
  
  3. * be empty after this call returns. 
    4.   
  
  
  4. */ 
    5.   
  
  
  5. public void clear() { 
    6.   
  
  
  6. modCount++; 
    7.   
  
  
  7.  
    8.   
  
  
  8. // clear to let GC do its work 
    9.   
  
  
  9. for (int i = 0; i < size; i++) 
    10.   
  
  
  10. elementData[i] = null; 
    11.   
  
  
  11.  
    12.   
  
  
  12. size = 0; 
    13.   
  
  
  13. } 
    14.

显式地设置强引用对象为null，或让其超出对象的生命周期范围，则垃圾回收器认为该对象不存在引用，就会回收这个对象。具体什么时候收集这要取决于具体的垃圾回收器。

软引用

如果一个对象只具有软引用(Soft Reference)，当内存空间充足时，垃圾回收器就不会回收它;如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。让我们来看一个例子具体了解一下：

 
 
 
      
  
  
  1. String str = new String("abc"); 
    2.   
  
  
  2. SoftReference softReference = new SoftReference<>(str); 
    3.   
  
  
  3. String result = softReference.get(); 
    4.

让我们来看一下get()：

 
 
 
      
  
  
  1. public T get() { 
    2.   
  
  
  2. T o = super.get(); 
    3.   
  
  
  3. // timestamp代表上一次软引用上一次被使用的时间(初始化、get()) 
    4.   
  
  
  4. // clock代表上一次GC的时间 
    5.   
  
  
  5. if (o != null && this.timestamp != clock) 
    6.   
  
  
  6. this.timestamp = clock; 
    7.   
  
  
  7. return o; 
    8.   
  
  
  8. } 
    9.

因此，软引用在被垃圾回收时，也遵循LRU法则，优先回收最近最少被使用的对象进行回收。

软引用的使用场景多是内存敏感的高速缓存。具体来说，就是我们希望将数据存放到缓存中，这样可以快速进行读取。但是，当 JVM 中内存不够用时，我们又不希望缓存数据会占用到 JVM 的内存。例如配合ReferenceQueue，如果软引用所引用对象被垃圾回收，JVM 就会把这个软引用加入到与之关联的引用队列中：

 
 
 
      
  
  
  1. ReferenceQueue referenceQueue = new ReferenceQueue<>(); 
    2.   
  
  
  2. String str = new String("abc"); 
    3.   
  
  
  3. SoftReference softReference = new SoftReference<>(str, referenceQueue); 
    4.   
  
  
  4.  
    5.   
  
  
  5. str = null; 
    6.   
  
  
  6. // Notify GC 
    7.   
  
  
  7. System.gc(); 
    8.   
  
  
  8.  
    9.   
  
  
  9. System.out.println(softReference.get()); // abc 
    10.   
  
  
  10.  
    11.   
  
  
  11. Reference reference = referenceQueue.poll(); 
    12.   
  
  
  12. System.out.println(reference); //null 
    13.

但是需要注意的是，如果使用软引用缓存，有可能导致Full GC增多。

弱引用

如果一个对象只具有弱引用(Weak Reference)，其生命周期相比于软引用更加短暂。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会对它进行回收。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。其使用为：

 
 
 
      
  
  
  1. String str = new String("abc"); 
    2.   
  
  
  2. WeakReference weakReference = new WeakReference<>(str); 
    3.   
  
  
  3. str = weakReference.get(); 
    4.

讲到弱引用，就不得不提到WeakHashMap。和HashMap相比，当我们给 JVM 分配的内存不足的时候，HashMap 宁可抛出 OutOfMemoryError 异常，也不会回收其相应的没有被引用的对象，而 WeakHashMap 则会回收存储在其中但有被引用的对象。

WeakHashMap 通过将一些没有被引用的键的值赋值为 null ，这样的话就会告知GC去回收这些存储的值了。假如我们特地传入 key 为 null 的键，WeakHashMap 会将键设置为特殊的 Oject，源码为：

 
 
 
      
  
  
  1. public V put(K key, V value) { 
    2.   
  
  
  2. // key会被重新赋值 
    3.   
  
  
  3. Object k = maskNull(key); 
    4.   
  
  
  4. int h = hash(k); 
    5.   
  
  
  5. Entry[] tab = getTable(); 
    6.   
  
  
  6. int i = indexFor(h, tab.length); 
    7.   
  
  
  7.  
    8.   
  
  
  8. for (Entry e = tab[i]; e != null; ee = e.next) { 
    9.   
  
  
  9. if (h == e.hash && eq(k, e.get())) { 
    10.   
  
  
  10. V oldValue = e.value; 
    11.   
  
  
  11. if (value != oldValue) 
    12.   
  
  
  12. e.value = value; 
    13.   
  
  
  13. return oldValue; 
    14.   
  
  
  14. } 
    15.   
  
  
  15. } 
    16.   
  
  
  16.  
    17.   
  
  
  17. modCount++; 
    18.   
  
  
  18. Entry e = tab[i]; 
    19.   
  
  
  19. tab[i] = new Entry<>(k, value, queue, h, e); 
    20.   
  
  
  20. if (++size >= threshold) 
    21.   
  
  
  21. resize(tab.length * 2); 
    22.   
  
  
  22. return null; 
    23.   
  
  
  23. } 
    24.   
  
  
  24.  
    25.   
  
  
  25. /** 
    26.   
  
  
  26. * Value representing null keys inside tables. 
    27.   
  
  
  27. * 特殊的key 
    28.   
  
  
  28. */ 
    29.   
  
  
  29. private static final Object NULL_KEY = new Object(); 
    30.   
  
  
  30.  
    31.   
  
  
  31. /** 
    32.   
  
  
  32. * Use NULL_KEY for key if it is null. 
    33.   
  
  
  33. */ 
    34.   
  
  
  34. private static Object maskNull(Object key) { 
    35.   
  
  
  35. return (key == null) ? NULL_KEY : key; 
    36.   
  
  
  36. } 
    37.

虚引用

虚引用(PhantomReference),顾名思义，就是形同虚设。与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。

虚引用主要用来跟踪对象被垃圾回收器回收的活动。 虚引用与软引用和弱引用的一个区别在于：

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

例如：

 
 
 
      
  
  
  1. String str = new String("abc"); 
    2.   
  
  
  2. ReferenceQueue queue = new ReferenceQueue(); 
    3.   
  
  
  3. // 创建虚引用，要求必须与一个引用队列关联 
    4.   
  
  
  4. PhantomReference pr = new PhantomReference(str, queue); 
    5.

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

总结

Java 中4种引用的级别和强度由高到低依次为：强引用 -> 软引用 -> 弱引用 -> 虚引用

通过表格，说明其特性：


当前名称：Java 中的四种引用
文章来源：http://wtcwzsj.com/article/cdjhdii.html

其他资讯


关于我们
我们的服务
网站建设案例
新闻动态
联系我们

135-1821-9792

公司服务热线
友情链接： 微信公众号开发   成都画册快印   成都包装设计公司   成都VI设计   成都防护栏   珀金斯发电机维修   UI设计   都江堰发电机   沃尔沃电机组维修保养   成都门头招牌制作   

Copyright © 2009-2022 www.wtcwzsj.com 青羊区广皓图文设计工作室（个体工商户） 版权所有　蜀ICP备19037934号