java弱引用软引用

在Java中，引用分为强引用、软引用、弱引用和虚引用四种。

• 强引用，代码中普遍存在的形式，例如常见的普通类new出对象后的引用。GC不会回收强引用的对象。
• 软引用，软引用对象会在内存溢出异常之前进行回收，也就是说在内存富裕的情况下GC不回收软引用。它可通过SoftReference类实现。
• 弱引用，弱引用对象会在下一次GC时被回收，也就是说不管内存富不富裕，当GC时都会回收弱引用。它可通过WeakReference类实现。
• 虚引用，虚引用不会改变对象的生存时间，它只是让对象在被GC时能收到一个系统通知。

• 了解了所有引用类型后看下如何基于弱引用对程序进行内存泄漏检测。

  假如在你的程序中有某类的对象很可能会造成内存泄漏，姑且称为MaybeMemoryLeak类。内存泄漏就是虚拟机在做垃圾回收时某些“垃圾”由于某些原因而导致无法回收，每次实例化出来的对象都无法回收，最终导致内存爆了。也就是如果某些MaybeMemoryLeak应该被回收的对象无法回收，就会导致内存泄漏。

  如果无法避免内存泄漏的可能性，那么如何检测内存泄漏现象呢？

  这里就要用到上面所说的弱引用，它能很好判断MaybeMemoryLeak有没有被GC回收，被弱引用关联的对象只能生存到下一次垃圾回收发生之前，即如果某MaybeMemoryLeak对象只被某弱引用关联，则它会在下次垃圾回收时被回收，但如果MaybeMemoryLeak对象除了被弱引用关联外还被其他对象强引用，那么MaybeMemoryLeak对象是不会被回收的，根据这些条件就可以判断是否有MaybeMemoryLeak内存泄漏了。

  在实际的实现中可以通过WeakHashMap来实现弱引用，只需将MaybeMemoryLeak对象put到WeakHashMap中，例如weakMap.put(“a”,maybeMemoryLeak)，当maybeMemoryLeak及其包含的元素没有被其它任何类加载器中的元素引用到时，JVM发生垃圾回收时则会把maybeMemoryLeak对象回收，否则就将一直回收不了。

  这里使用一个WeakHashMap用于追踪MaybeMemoryLeak对象，在查找内存泄漏之前要先强制调用System.gc();进行一次垃圾回收，保证没问题的MaybeMemoryLeak对象都被回收掉，这时可以查看WeakHashMap对象还存在哪些MaybeMemoryLeak对象，如果存在某些“垃圾”MaybeMemoryLeak对象，则属于内存泄漏。

  弱引用

• 现在有如下两个类class A class B，在JVM上生成他们两个类的实例分别为 instance a  instance b

  有如下表达式:

  A a = new A();

  B b = new B();

  两个强引用对象就生成了，好吧，那么这个时候我做一下修改：

  A a = new A();

  B b = new B(a);

  B的默认构造函数上是需要一个A的实例作为参数的，那么这个时候 A和B就产生了依赖，也可以说a和b产生了依赖，我们再用一个接近内存结构的图来表达：

   

  

  a是对象A的引用，b是对象B的引用，对象B同时还依赖对象A，那么这个时候我们认为从对象B是可以到达对象A的。

  于是我又修改了一下代码

  A a = new A();

  B b = new B(a);

  a = null;

  A对象的引用a置空了，a不再指向对象A的地址，我们都知道当一个对象不再被其他对象引用的时候，是会被GC回收的，很显然及时a=null，那么A对象也是不可能被回收的，因为B依然依赖与A，在这个时候，造成了内存泄漏！

  那么如何避免上面的例子中内存泄漏呢？

  很简单：

  A a = new A();

  B b = new B(a);

  a = null;

  b = null;

  这个时候B对象再也没有被任何引用，A对象只被B对象引用，尽管这样，GC也是可以同时回收他们俩的，因为他们处于不可到达区域。

   

  弱引用来了！

  A a = new A();

  WeakReference wr = new WeakReference(a);

  //B b = new B(a);

   

  

  当 a=null ，这个时候A只被弱引用依赖，那么GC会立刻回收A这个对象，这就是弱引用的好处！他可以在你对对象结构和拓扑不是很清晰的情况下，帮助你合理的释放对象，造成不必要的内存泄漏！！

  
  

• WeakReference与SoftReference都可以用来保存对象的实例引用，这两个类与垃圾回收有关。
  

  WeakReference是弱引用，其中保存的对象实例可以被GC回收掉。这个类通常用于在某处保存对象引用，而又不干扰该对象被GC回收，通常用于Debug、内存监视工具等程序中。因为这类程序一般要求即要观察到对象，又不能影响该对象正常的GC过程。

  最近在JDK的Proxy类的实现代码中也发现了Weakrefrence的应用，Proxy会把动态生成的Class实例暂存于一个由Weakrefrence构成的Map中作为Cache。

  
  

  SoftReference是强引用，它保存的对象实例，除非JVM即将OutOfMemory，否则不会被GC回收。这个特性使得它特别适合设计对象Cache。对于Cache，我们希望被缓存的对象最好始终常驻内存，但是如果JVM内存吃紧，为了不发生OutOfMemoryError导致系统崩溃，必要的时候也允许JVM回收Cache的内存，待后续合适的时机再把数据重新Load到Cache中。这样可以系统设计得更具弹性。

   

  WeakReference的一个测试程序：

  
  

  Java代码  

  1. import java.lang.ref.WeakReference;  
  2.   
  3. public class WeakReferenceTest {  
  4.   
  5.     /** 
  6.      * @param args 
  7.      */  
  8.     public static void main(String[] args) {  
  9.         A a = new A();  
  10.         a.str = "Hello, reference";  
  11.         WeakReference<A> weak = new WeakReference<A>(a);  
  12.         a = null;  
  13.         int i = 0;  
  14.         while (weak.get() != null) {  
  15.             System.out.println(String.format("Get str from object of WeakReference: %s, count: %d", weak.get().str, ++i));  
  16.             if (i % 10 == 0) {  
  17.                 System.gc();  
  18.                 System.out.println("System.gc() was invoked!");  
  19.             }  
  20.             try {  
  21.                 Thread.sleep(500);  
  22.             } catch (InterruptedException e) {  
  23.   
  24.             }  
  25.         }  
  26.         System.out.println("object a was cleared by JVM!");  
  27.     }  
  28.   
  29. }  

   程序运行结果：

  1. Get str from object of WeakReference: Hello, reference, count: 1  
  2. Get str from object of WeakReference: Hello, reference, count: 2  
  3. Get str from object of WeakReference: Hello, reference, count: 3  
  4. Get str from object of WeakReference: Hello, reference, count: 4  
  5. Get str from object of WeakReference: Hello, reference, count: 5  
  6. Get str from object of WeakReference: Hello, reference, count: 6  
  7. Get str from object of WeakReference: Hello, reference, count: 7  
  8. Get str from object of WeakReference: Hello, reference, count: 8  
  9. Get str from object of WeakReference: Hello, reference, count: 9  
  10. Get str from object of WeakReference: Hello, reference, count: 10  
  11. System.gc() was invoked!   
  12. object a was cleared by JVM!  
  
  

  SoftReference的一个测试程序：

  1. import java.lang.ref.SoftReference;  
  2.   
  3. public class SoftReferenceTest {  
  4.   
  5.     /** 
  6.      * @param args 
  7.      */  
  8.     public static void main(String[] args) {  
  9.         A a = new A();  
  10.         a.str = "Hello, reference";  
  11.         SoftReference<A> sr = new SoftReference<A>(a);  
  12.         a = null;  
  13.         int i = 0;  
  14.         while (sr.get() != null) {  
  15.             System.out.println(String.format("Get str from object of SoftReference: %s, count: %d", sr.get().str, ++i));  
  16.             if (i % 10 == 0) {  
  17.                 System.gc();  
  18.                 System.out.println("System.gc() was invoked!");  
  19.             }  
  20.             try {  
  21.                 Thread.sleep(500);  
  22.             } catch (InterruptedException e) {  
  23.   
  24.             }  
  25.         }  
  26.         System.out.println("object a was cleared by JVM!");  
  27.     }  
  28.   
  29. }  

   程序运行结果：

  1. Get str from object of SoftReference: Hello, reference, count: 1  
  2. Get str from object of SoftReference: Hello, reference, count: 2  
  3. Get str from object of SoftReference: Hello, reference, count: 3  
  4. Get str from object of SoftReference: Hello, reference, count: 4  
  5. Get str from object of SoftReference: Hello, reference, count: 5  
  6. Get str from object of SoftReference: Hello, reference, count: 6  
  7. Get str from object of SoftReference: Hello, reference, count: 7  
  8. Get str from object of SoftReference: Hello, reference, count: 8  
  9. Get str from object of SoftReference: Hello, reference, count: 9  
  10. Get str from object of SoftReference: Hello, reference, count: 10  
  11. System.gc() was invoked!   
  12. Get str from object of SoftReference: Hello, reference, count: 11  
  13. Get str from object of SoftReference: Hello, reference, count: 12  
  14. Get str from object of SoftReference: Hello, reference, count: 13  
  15. Get str from object of SoftReference: Hello, reference, count: 14  
  16. Get str from object of SoftReference: Hello, reference, count: 15  
  17. Get str from object of SoftReference: Hello, reference, count: 16  
  18. Get str from object of SoftReference: Hello, reference, count: 17  
  19. Get str from object of SoftReference: Hello, reference, count: 18  
  20. Get str from object of SoftReference: Hello, reference, count: 19  
  21. Get str from object of SoftReference: Hello, reference, count: 20  
  22. System.gc() was invoked!   
  23. Get str from object of SoftReference: Hello, reference, count: 21  
  24. Get str from object of SoftReference: Hello, reference, count: 22  
  25. Get str from object of SoftReference: Hello, reference, count: 23  
  26. Get str from object of SoftReference: Hello, reference, count: 24  
  27. Get str from object of SoftReference: Hello, reference, count: 25  
  28. Get str from object of SoftReference: Hello, reference, count: 26  
  29. Get str from object of SoftReference: Hello, reference, count: 27  
  30. Get str from object of SoftReference: Hello, reference, count: 28  
  自己的标注 写道
  上面的打印结果会一直持续下去。 因为soft.get()一直不会为空
  SoftReference比WeakReference生命力更强，当JVM的内存不吃紧时，即使引用的对象被置为空了，Soft还可以保留对该对象的引用，此时的JVM内存池实际上还保有原来对象，只有当内存吃紧的情况下JVM才会清除Soft的引用对象，并且会在未来重新加载该引用的对象。 
  
  而WeakReference则当清理内存池时会自动清理掉引用的对象。