前言
 
Java执行GC判断对象是否存活有两种方式其中一种是引用计数。
 
 
 
 
引用计数：Java堆中每一个对象都有一个引用计数属性，引用每新增1次计数加1，引用每释放1次计数减1。
 
 
在JDK 1.2以前的版本中，若一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于(reachable)可达状态，程序才能使用它。
 
从JDK 1.2版本开始，对象的引用被划分为4种级别，从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为：强引用、软引用、弱引用和虚引用。
 
 
正文
 
(一) 强引用(StrongReference)
 
强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。如下：
 
    Object strongReference = new Object();
 
当内存空间不足时，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。 
 如果强引用对象不使用时，需要弱化从而使GC能够回收，如下：
 
    strongReference = null;
 
显式地设置strongReference对象为null，或让其超出对象的生命周期范围，则gc认为该对象不存在引用，这时就可以回收这个对象。具体什么时候收集这要取决于GC算法。
 
    public void test() {
        Object strongReference = new Object();
        // 省略其他操作
    }
 
在一个方法的内部有一个强引用，这个引用保存在Java栈中，而真正的引用内容(Object)保存在Java堆中。 
 当这个方法运行完成后，就会退出方法栈，则引用对象的引用数为0，这个对象会被回收。
 
但是如果这个strongReference是全局变量时，就需要在不用这个对象时赋值为null，因为强引用不会被垃圾回收。
 
ArrayList的Clear方法：
 
 
在ArrayList类中定义了一个elementData数组，在调用clear方法清空数组时，每个数组元素被赋值为null。 
 不同于elementData=null，强引用仍然存在，避免在后续调用add()等方法添加元素时进行内存的重新分配。 
 使用如clear()方法内存数组中存放的引用类型进行内存释放特别适用，这样就可以及时释放内存。
 
(二) 软引用(SoftReference)
 
如果一个对象只具有软引用，则内存空间充足时，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。
 
 
 
软引用可用来实现内存敏感的高速缓存。
 
 
    // 强引用
    String strongReference = new String("abc");
    // 软引用
    String str = new String("abc");
    SoftReference<String> softReference = new SoftReference<String>(str);
 
软引用可以和一个引用队列(ReferenceQueue)联合使用。如果软引用所引用对象被垃圾回收，JAVA虚拟机就会把这个软引用加入到与之关联的引用队列中。
 
    ReferenceQueue<String> referenceQueue = new ReferenceQueue<>();
    String str = new String("abc");
    SoftReference<String> softReference = new SoftReference<>(str, referenceQueue);

    str = null;
    // Notify GC
    System.gc();

    System.out.println(softReference.get()); // abc

    Reference<? extends String> reference = referenceQueue.poll();
    System.out.println(reference); //null
 
 
 
注意：软引用对象是在jvm内存不够的时候才会被回收，我们调用System.gc()方法只是起通知作用，JVM什么时候扫描回收对象是JVM自己的状态决定的。就算扫描到软引用对象也不一定会回收它，只有内存不够的时候才会回收。
 
 
当内存不足时，JVM首先将软引用中的对象引用置为null，然后通知垃圾回收器进行回收：
 
    if(JVM内存不足) {
        // 将软引用中的对象引用置为null
        str = null;
        // 通知垃圾回收器进行回收
        System.gc();
    }
 
也就是说，垃圾收集线程会在虚拟机抛出OutOfMemoryError之前回收软引用对象，而且虚拟机会尽可能优先回收长时间闲置不用的软引用对象。对那些刚构建的或刚使用过的“较新的”软对象会被虚拟机尽可能保留，这就是引入引用队列ReferenceQueue的原因。
 
应用场景：
 
浏览器的后退按钮。按后退时，这个后退时显示的网页内容是重新进行请求还是从缓存中取出呢？这就要看具体的实现策略了。
 
如果一个网页在浏览结束时就进行内容的回收，则按后退查看前面浏览过的页面时，需要重新构建；
如果将浏览过的网页存储到内存中会造成内存的大量浪费，甚至会造成内存溢出。
 
这时候就可以使用软引用，很好的解决了实际的问题：
 
    // 获取浏览器对象进行浏览
    Browser browser = new Browser();
    // 从后台程序加载浏览页面
    BrowserPage page = browser.getPage();
    // 将浏览完毕的页面置为软引用
    SoftReference softReference = new SoftReference(page);

    // 回退或者再次浏览此页面时
    if(softReference.get() != null) {
        // 内存充足，还没有被回收器回收，直接获取缓存
        page = softReference.get();
    } else {
        // 内存不足，软引用的对象已经回收
        page = browser.getPage();
        // 重新构建软引用
        softReference = new SoftReference(page);
    }
 
(三) 弱引用(WeakReference)
 
弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
 
    String str = new String("abc");
    WeakReference<String> weakReference = new WeakReference<>(str);
    str = null;
 
JVM首先将软引用中的对象引用置为null，然后通知垃圾回收器进行回收：
 
    str = null;
    System.gc();
 
 
 
注意：如果一个对象是偶尔(很少)的使用，并且希望在使用时随时就能获取到，但又不想影响此对象的垃圾收集，那么你应该用Weak Reference来记住此对象。
 
 
下面的代码会让一个弱引用再次变为一个强引用：
 
    String str = new String("abc");
    WeakReference<String> weakReference = new WeakReference<>(str);
    // 弱引用转强引用
    String strongReference = weakReference.get();
 
同样，弱引用可以和一个引用队列(ReferenceQueue)联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
 
简单测试：
 
GCTarget.java
 
public class GCTarget {
    // 对象的ID
    public String id;

    // 占用内存空间
    byte[] buffer = new byte[1024];

    public GCTarget(String id) {
        this.id = id;
    }

    protected void finalize() throws Throwable {
        // 执行垃圾回收时打印显示对象ID
        System.out.println("Finalizing GCTarget, id is : " + id);
    }
}
 
GCTargetWeakReference.java
 
public class GCTargetWeakReference extends WeakReference<GCTarget> {
    // 弱引用的ID
    public String id;

    public GCTargetWeakReference(GCTarget gcTarget,
              ReferenceQueue<? super GCTarget> queue) {
        super(gcTarget, queue);
        this.id = gcTarget.id;
    }

    protected void finalize() {
        System.out.println("Finalizing GCTargetWeakReference " + id);
    }
}
 
WeakReferenceTest.java
 
public class WeakReferenceTest {
    // 弱引用队列
    private final static ReferenceQueue<GCTarget> REFERENCE_QUEUE = new ReferenceQueue<>();

    public static void main(String[] args) {
        LinkedList<GCTargetWeakReference> gcTargetList = new LinkedList<>();

        // 创建弱引用的对象，依次加入链表中
        for (int i = 0; i < 5; i++) {
            GCTarget gcTarget = new GCTarget(String.valueOf(i));
            GCTargetWeakReference weakReference = new GCTargetWeakReference(gcTarget,
                REFERENCE_QUEUE);
            gcTargetList.add(weakReference);

            System.out.println("Just created GCTargetWeakReference obj: " +
                gcTargetList.getLast());
        }

        // 通知GC进行垃圾回收
        System.gc();

        try {
            // 休息几分钟，等待上面的垃圾回收线程运行完成
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 检查关联的引用队列是否为空
        Reference<? extends GCTarget> reference;
        while((reference = REFERENCE_QUEUE.poll()) != null) {
            if(reference instanceof GCTargetWeakReference) {
                System.out.println("In queue, id is: " +
                    ((GCTargetWeakReference) (reference)).id);
            }
        }
    }
}
 
运行WeakReferenceTest.java，运行结果如下：
 
 
可见WeakReference对象的生命周期基本由垃圾回收器决定，一旦垃圾回收线程发现了弱引用对象，在下一次GC过程中就会对其进行回收。
 
(四) 虚引用(PhantomReference)
 
虚引用顾名思义，就是形同虚设。与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
 
应用场景：
 
虚引用主要用来跟踪对象被垃圾回收器回收的活动。 
 虚引用与软引用和弱引用的一个区别在于：
 
 
 
虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。
 
 
    String str = new String("abc");
    ReferenceQueue queue = new ReferenceQueue();
    // 创建虚引用，要求必须与一个引用队列关联
    PhantomReference pr = new PhantomReference(str, queue);
 
程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要进行垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
 
总结
 
 
 
Java中4种引用的级别和强度由高到低依次为：强引用 -> 软引用 -> 弱引用 -> 虚引用
 
 
当垃圾回收器回收时，某些对象会被回收，某些不会被回收。垃圾回收器会从根对象Object来标记存活的对象，然后将某些不可达的对象和一些引用的对象进行回收。
 
通过表格来说明一下，如下：
 

 
引用类型
被垃圾回收时间
用途
生存时间
强引用
从来不会
对象的一般状态
JVM停止运行时终止
软引用
当内存不足时
对象缓存
内存不足时终止
弱引用
正常垃圾回收时
对象缓存
垃圾回收后终止
虚引用
正常垃圾回收时
跟踪对象的垃圾回收
垃圾回收后终止
 
 
欢迎关注技术公众号： 零壹技术栈
 
 
本帐号将持续分享后端技术干货，包括虚拟机基础，多线程编程，高性能框架，异步、缓存和消息中间件，分布式和微服务，架构学习和进阶等学习资料和文章。

目录
 
一、强引用
 
二、软引用
 
三、弱引用
 
四、虚引用
 
五、总结
 

在JDK1.2以前的版本中，当一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于可触及状态，程序才能使用它。这就像在商店购买了某样物品后，如果有用就一直保留它，否则就把它扔到垃圾箱，由清洁工人收走。一般说来，如果物品已经被扔到垃圾箱，想再把它捡回来使用就不可能了。
 
但有时候情况并不这么简单，可能会遇到可有可无的"鸡肋"物品。这种物品现在已经无用了，保留它会占空间，但是立刻扔掉它也不划算，因为也许将来还会派用场。对于这样的可有可无的物品：如果家里空间足够，就先把它保留在家里，如果家里空间不够，即使把家里所有的垃圾清除，还是无法容纳那些必不可少的生活用品，那么再扔掉这些可有可无的物品。
 
在Java中，虽然不需要程序员手动去管理对象的生命周期，但是如果希望某些对象具备一定的生命周期的话（比如内存不足时JVM就会自动回收某些对象从而避免OutOfMemory的错误）就需要用到软引用和弱引用了。
 
从Java SE2开始，就提供了四种类型的引用：强引用、软引用、弱引用和虚引用。Java中提供这四种引用类型主要有两个目的：第一是可以让程序员通过代码的方式决定某些对象的生命周期；第二是有利于JVM进行垃圾回收。
 
一、强引用
 
之前我们使用的大部分引用实际上都是强引用，这是使用最普遍的引用。比如下面这段代码中的object和str都是强引用：
 
Object object = new Object();
String str = "StrongReference";
 
如果一个对象具有强引用，那就类似于必不可少的物品，不会被垃圾回收器回收。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不回收这种对象。
 
public class StrongReference {
	public static void main(String[] args) {
		new StrongReference().method1();
	}
	public void method1(){
		Object object=new Object();
		Object[] objArr=new Object[Integer.MAX_VALUE];
	}
}
 
运行结果：
 
当运行至Object[] objArr = new Object[Integer.MAX_VALUE]时，如果内存不足，JVM会抛出OOM错误也不会回收object指向的对象。不过要注意的是，当method1运行完之后，object和objArr都已经不存在了，所以它们指向的对象都会被JVM回收。
 
如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。
 
比如ArraryList类的clear方法中就是通过将引用赋值为null来实现清理工作的
 
public void clear() {
      modCount++;

      // Let gc do its work
      for (int i = 0; i < size; i++)
          elementData[i] = null;

      size = 0;
}
 
在ArrayList类中定义了一个私有的变量elementData数组，在调用方法清空数组时可以看到为每个数组内容赋值为null。不同于elementData=null，强引用仍然存在，避免在后续调用 add()等方法添加元素时进行重新的内存分配。使用如clear()方法中释放内存的方法对数组中存放的引用类型特别适用，这样就可以及时释放内存。
 
 
 
二、软引用
 
软引用是用来描述一些有用但并不是必需的对象，在Java中用java.lang.ref.SoftReference类来表示。对于软引用关联着的对象，只有在内存不足的时候JVM才会回收该对象。因此，这一点可以很好地用来解决OOM的问题，并且这个特性很适合用来实现缓存：比如网页缓存、图片缓存等。
 
软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被JVM回收，这个软引用就会被加入到与之关联的引用队列中。
 
import java.lang.ref.SoftReference;

public class SoftRef {  

    public static void main(String[] args){  
        System.out.println("start");            
        Obj obj = new Obj();            
        SoftReference<Obj> sr = new SoftReference<Obj>(obj);  
        obj = null;  
        System.out.println(sr.get());  
        System.out.println("end");     
    }       
}  

class Obj{  
    int[] obj ;  
    public Obj(){  
        obj = new int[1000];  
    }  
}
 
 
当内存足够大时可以把数组存入软引用，取数据时就可从内存里取数据，提高运行效率
 
软引用在实际中有重要的应用，例如浏览器的后退按钮，这个后退时显示的网页内容可以重新进行请求或者从缓存中取出：
 
（1）如果一个网页在浏览结束时就进行内容的回收，则按后退查看前面浏览过的页面时，需要重新构建
 
（2）如果将浏览过的网页存储到内存中会造成内存的大量浪费，甚至会造成内存溢出这时候就可以使用软引用
 
 
 
三、弱引用
 
弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。在java中，用java.lang.ref.WeakReference类来表示。
 
弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。所以被软引用关联的对象只有在内存不足时才会被回收，而被弱引用关联的对象在JVM进行垃圾回收时总会被回收。
 
import java.lang.ref.WeakReference;

public class WeakRef {
    public static void main(String[] args) {
        WeakReference<String> sr = new WeakReference<String>(new String("hello"));
        System.out.println(sr.get());
        System.gc();                //通知JVM的gc进行垃圾回收
        System.out.println(sr.get());
    }
}
 
运行结果：
 
 
在使用软引用和弱引用的时候，我们可以显示地通过System.gc()来通知JVM进行垃圾回收，但是要注意的是，虽然发出了通知，JVM不一定会立刻执行，也就是说这句是无法确保此时JVM一定会进行垃圾回收的。
 
 
 
弱引用还可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
 
Object o = new Object(); //只要o还指向对象就不会被回收
WeakReference<Object> wr = new WeakReference<Object>(o);
 
当要获得weak reference引用的object时, 首先需要判断它是否已经被回收，如果wr.get()方法为空, 那么说明weakCar指向的对象已经被回收了。
 
应用场景：如果一个对象是偶尔的使用，并且希望在使用时随时就能获取到，但又不想影响此对象的垃圾收集，那么应该用 Weak Reference 来记住此对象。或者想引用一个对象，但是这个对象有自己的生命周期，你不想介入这个对象的生命周期，这时候就应该用弱引用，这个引用不会在对象的垃圾回收判断中产生任何附加的影响。
 
 
 
四、虚引用
 
虚引用和前面的软引用、弱引用不同，它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收的活动。
 
虚引用必须和引用队列关联使用，当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
 
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
 
 
public class PhantomRef {
    public static void main(String[] args) {
        ReferenceQueue<String> queue = new ReferenceQueue<String>();
        PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue);
        System.out.println(pr.get());
    }
}
 
 
 
五、总结
 
引用类型
被回收时间
用途
生存时间
强引用
从来不会
对象的一般状态
JVM停止运行时
软引用
内存不足时
对象缓存
内存不足时
弱引用
jvm垃圾回收时
对象缓存
gc运行后
虚引用
未知
未知
未知
在实际程序设计中一般很少使用弱引用与虚引用，使用软引用的情况较多，这是因为软引用可以加速JVM对垃圾内存的回收速度，可以维护系统的运行安全，防止内存溢出（OutOfMemory）等问题的产生
 
 
 
利用软引用和弱引用解决OOM问题：假如有一个应用需要读取大量的本地图片，如果每次读取图片都从硬盘读取，则会严重影响性能，但是如果全部加载到内存当中，又有可能造成内存溢出，此时使用软引用可以解决这个问题。
 
设计思路是：用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题。
 

参考资料：
 
1、https://www.cnblogs.com/dolphin0520/p/3784171.html
 
2、https://blog.csdn.net/junjunba2689/article/details/80601729

本文章转载自 https://www.cnblogs.com/skywang12345/p/3154474.html
 
1 Java引用介绍
 
   Java从1.2版本开始引入了4种引用，这4种引用的级别由高到低依次为：
 
   强引用  >  软引用  >  弱引用  >  虚引用
 
⑴强引用（StrongReference）
     强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。
 
⑵软引用（SoftReference）
 
    如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。
 
    软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
 
⑶弱引用（WeakReference）
 
    弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
 
    弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
 
⑷虚引用（PhantomReference）
 
    “虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
 
    虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列 （ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之 关联的引用队列中。
 
 
 
由于引用和内存回收关系紧密。下面，先通过实例对内存回收有个认识；然后，进一步通过引用实例加深对引用的了解。
 
 
 
 
 
 
 

2 内存回收
 
创建公共类MyDate，它的作用是覆盖finalize()函数：在finalize()中输出打印信息，方便追踪。
 
说明：finalize()函数是在JVM回收内存时执行的，但JVM并不保证在回收内存时一定会调用finalize()。
 
MyDate代码如下：
 
 
package com.skywang.java;

import java.util.Date;

public class MyDate extends Date { 

    /** Creates a new instance of MyDate */
    public MyDate() {
    }
    // 覆盖finalize()方法
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("obj [Date: " + this.getTime() + "] is gc");
    }   

    public String toString() {
        return "Date: " + this.getTime();
    }
}
 
 
在这个类中，对java.util.Date类进行了扩展，并重写了finalize()和toString()方法。
 
 
 
创建公共类ReferenceTest，它的作用是定义一个方法drainMemory()：消耗大量内存，以此来引发JVM回收内存。
 
ReferenceTest代码如下：
 
 
package com.skywang.java;

public class ReferenceTest {   
    /** Creates a new instance of ReferenceTest */
    public ReferenceTest() {
    }   
    
    // 消耗大量内存
    public static void drainMemory() {
        String[] array = new String[1024 * 10];
        for(int i = 0; i < 1024 * 10; i++) {
            for(int j = 'a'; j <= 'z'; j++) {
                array[i] += (char)j;
            }           
        }
    }
} 
 
 
在这个类中定义了一个静态方法drainMemory()，此方法旨在消耗大量的内存，促使JVM运行垃圾回收。
 
 
 
有了上面两个公共类之后，我们即可测试JVM什么时候进行垃圾回收。下面分3种情况进行测试：
 
情况1：清除对象
 
实现代码：
 
 
package com.skywang.java;

public class NoGarbageRetrieve {

    public static void main(String[] args) {
        MyDate date = new MyDate();
        date = null;
    }
}
 
 
运行结果：
 
<无任何输出>
 
结果分析：date虽然设为null，但由于JVM没有执行垃圾回收操作，MyDate的finalize()方法没有被运行。
 
 
 
情况2：显式调用垃圾回收
 
实现代码： 
 
 
package com.skywang.java;

public class ExplicitGarbageRetrieve {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyDate date = new MyDate();
        date = null;
        System.gc();
    }

}
 
 
运行结果：
 
obj [Date: 1372137067328] is gc
 
结果分析：调用了System.gc()，使JVM运行垃圾回收，MyDate的finalize()方法被运行。
 
 
 
情况3：隐式调用垃圾回收
 
实现代码： 
 
 
package com.skywang.java;

public class ImplicitGarbageRetrieve {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyDate date = new MyDate();
        date = null;
        ReferenceTest.drainMemory();
    }

} 
 
 
运行结果：
 
obj [Date: 1372137171965] is gc
 
结果分析：虽然没有显式调用垃圾回收方法System.gc()，但是由于运行了耗费大量内存的方法，触发JVM进行垃圾回收。
 
 
 
总结：JVM的垃圾回收机制，在内存充足的情况下，除非你显式调用System.gc()，否则它不会进行垃圾回收；在内存不足的情况下，垃圾回收将自动运行
 
 
 
 
 
 
 

3、Java对引用的分类
 
3.1 强引用
 
实例代码：
 
 
package com.skywang.java;

public class StrongReferenceTest {

    public static void main(String[] args) {
        MyDate date = new MyDate();
        System.gc();
    }
}
 
 
运行结果：
 
<无任何输出>
 
结果说明：即使显式调用了垃圾回收，但是用于date是强引用，date没有被回收。
 
 
 
3.2 软引用
 
实例代码：
 
 
package com.skywang.java;

import java.lang.ref.SoftReference;

public class SoftReferenceTest {

    public static void main(String[] args) {
        SoftReference ref = new SoftReference(new MyDate());
        ReferenceTest.drainMemory();
    }
}
 
 
运行结果：
 
<无任何输出>
 
结果说明：在内存不足时，软引用被终止。软引用被禁止时，
 
SoftReference ref = new SoftReference(new MyDate());
 ReferenceTest.drainMemory();
 
等价于
 
MyDate date = new MyDate();
 
// 由JVM决定运行
 If(JVM.内存不足()) {
 date = null;
 System.gc();
 }
 
 
 
3.3 弱引用
 
示例代码： 
 
 
package com.skywang.java;

import java.lang.ref.WeakReference;

public class WeakReferenceTest {

    public static void main(String[] args) {
        WeakReference ref = new WeakReference(new MyDate());
        System.gc(); 
    }
}
 
 
运行结果：
 
obj [Date: 1372142034360] is gc
 
结果说明：在JVM垃圾回收运行时，弱引用被终止.
 
WeakReference ref = new WeakReference(new MyDate());
 System.gc();
 
等同于：
 
MyDate date = new MyDate();
 
// 垃圾回收
 If(JVM.内存不足()) {
 date = null;
 System.gc();
 }
 
 
 
3. 4 假象引用
 
示例代码： 
 
 
package com.skywang.java;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.PhantomReference;

public class PhantomReferenceTest {

    public static void main(String[] args) {
        ReferenceQueue queue = new ReferenceQueue();
        PhantomReference ref = new PhantomReference(new MyDate(), queue);
        System.gc();
    }
}
 
 
运行结果：
 
obj [Date: 1372142282558] is gc
 
结果说明：假象引用，在实例化后，就被终止了。
 
ReferenceQueue queue = new ReferenceQueue();
 PhantomReference ref = new PhantomReference(new MyDate(), queue);
 System.gc();
 
等同于：
 
MyDate date = new MyDate();
 date = null;
 
 
 
 
 
可以用以下表格总结上面的内容： 
 
 
级别
 
 
什么时候被垃圾回收
 
 
用途
 
 
生存时间
 
 
强引用
 
 
从来不会
 
 
对象的一般状态
 
 
JVM停止运行时终止
 
 
软引用
 
 
在内存不足时
 
 
对象简单？缓存
 
 
内存不足时终止
 
 
弱引用
 
 
在垃圾回收时
 
 
对象缓存
 
 
gc运行后终止
 
 
虚引用
 
 
Unknown
 
 
Unknown
 
 
Unknown
 
 
 
 
 
 

        Java 如何有效地避免OOM：善于利用软引用和弱引用。
 
　　想必很多朋友对OOM（OutOfMemory）这个错误不会陌生，而当遇到这种错误如何有效地解决这个问题呢？今天我们就来说一下如何利用软引用和弱引用来有效地解决程序中出现的OOM问题。下面是本文的目录大纲：
 
　　第一、了解 强引用、软引用、弱引用、虚引用的概念
 
　   第二、进一步理解软引用和弱引用
 
　　第三、如何利用软引用和弱引用解决OOM问题
 
　　如果有不正之处，希望谅解和批评指正，不胜感激。
 
　　请尊重作者劳动成果，转载请标明原文链接：http://www.cnblogs.com/dolphin0520/p/3784171.html
 
一、了解 强引用、软引用、弱引用、虚引用的概念
 
　　在Java中，虽然不需要程序员手动去管理对象的生命周期，但是如果希望某些对象具备一定的生命周期的话（比如内存不足时JVM就会自动回收某些对象从而避免OutOfMemory的错误）就需要用到软引用和弱引用了。
 
　　从Java SE2开始，就提供了四种类型的引用：强引用、软引用、弱引用和虚引用。Java中提供这四种引用类型主要有两个目的：第一是可以让程序员通过代码的方式决定某些对象的生命周期；第二是有利于JVM进行垃圾回收。下面来阐述一下这四种类型引用的概念：
 
　　1.强引用（StrongReference）
 
　　强引用就是指在程序代码之中普遍存在的，比如下面这段代码中的object和str都是强引用：
 
Object object = new Object();

String str = "hello";
 
 
 
　　只要某个对象有强引用与之关联，JVM必定不会回收这个对象，即使在内存不足的情况下，JVM宁愿抛出OutOfMemory错误也不会回收这种对象。比如下面这段代码：
 
public class Main {

    public static void main(String[] args) {

        new Main().fun1();

    }


    public void fun1() {

        Object object = new Object();

        Object[] objArr = new Object[1000];

    }

}
 
　　当运行至Object[] objArr = new Object[1000];这句时，如果内存不足，JVM会抛出OOM错误也不会回收object指向的对象。不过要注意的是，当fun1运行完之后，object和objArr都已经不存在了，所以它们指向的对象都会被JVM回收。
 
　　如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。
 
　　比如Vector类的clear方法中就是通过将引用赋值为null来实现清理工作的：
 
   /**
     * Removes the element at the specified position in this Vector.
     * Shifts any subsequent elements to the left (subtracts one from their
     * indices).  Returns the element that was removed from the Vector.
     *
     * @throws ArrayIndexOutOfBoundsException if the index is out of range
     *         ({@code index < 0 || index >= size()})
     * @param index the index of the element to be removed
     * @return element that was removed
     * @since 1.2
     */
    public synchronized E remove(int index) {
        modCount++;
        if (index >= elementCount){
            throw new ArrayIndexOutOfBoundsException(index);
        }

        Object oldValue = elementData[index];

        int numMoved = elementCount - index - 1;
        if (numMoved > 0){
            System.arraycopy(elementData, index+1, elementData, index,numMoved);
        }
        
        elementData[--elementCount] = null; // Let gc do its work

        return (E)oldValue;
    }
 
　　2.软引用（SoftReference）
 
　　软引用是用来描述一些有用但并不是必需的对象，在Java中用java.lang.ref.SoftReference类来表示。对于软引用关联着的对象，只有在内存不足的时候JVM才会回收该对象。因此，这一点可以很好地用来解决OOM的问题，并且这个特性很适合用来实现缓存：比如网页缓存、图片缓存等。
 
　　软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被JVM回收，这个软引用就会被加入到与之关联的引用队列中。下面是一个使用示例：
 
import java.lang.ref.SoftReference;


public class Main {

    public static void main(String[] args) {


        SoftReference<String> sr = new SoftReference<String>(new String("hello"));

        System.out.println(sr.get());


    }
 
　　3.弱引用（WeakReference）
 
　　弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。在java中，用java.lang.ref.WeakReference类来表示。下面是使用示例：
 
import java.lang.ref.WeakReference;


public class Main {

    public static void main(String[] args) {


        WeakReference<String> sr = new WeakReference<String>(new String("hello"));


        System.out.println(sr.get());


        System.gc();                //通知JVM的gc进行垃圾回收


        System.out.println(sr.get());


    }

}
 
　　
 
输出结果为：       
 
hello
null
 
　　第二个输出结果是null，这说明只要JVM进行垃圾回收，被弱引用关联的对象必定会被回收掉。不过要注意的是，这里所说的被弱引用关联的对象是指只有弱引用与之关联，如果存在强引用同时与之关联，则进行垃圾回收时也不会回收该对象（软引用也是如此）。
 
　　弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被JVM回收，这个软引用就会被加入到与之关联的引用队列中。
 
　　4.虚引用（PhantomReference）
 
　　虚引用和前面的软引用、弱引用不同，它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。
 
　　要注意的是，虚引用必须和引用队列关联使用，当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
 
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

public class Main {
    public static void main(String[] args) {
        
        ReferenceQueue<String> queue = new ReferenceQueue<String>();
        
        PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue);
        
        System.out.println(pr.get());
        
    }
}
 
输出结果：
 
null
 
二、进一步理解软引用和弱引用
 
　　对于强引用，我们平时在编写代码时经常会用到。而对于其他三种类型的引用，使用得最多的就是软引用和弱引用，这2种既有相似之处又有区别。它们都是用来描述非必需对象的，但是被软引用关联的对象只有在内存不足时才会被回收，而被弱引用关联的对象在JVM进行垃圾回收时总会被回收。
 
　　在SoftReference类中，有三个方法，两个构造方法和一个get方法（WekReference类似）：
 
　　两个构造方法：
 
    public SoftReference(T referent) {
        super(referent);
        this.timestamp = clock;
    }

    public SoftReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
        this.timestamp = clock;
    }
 
　　get方法用来获取与软引用关联的对象的引用，如果该对象被回收了，则返回null。
 
 　　在使用软引用和弱引用的时候，我们可以显示地通过System.gc()来通知JVM进行垃圾回收，但是要注意的是，虽然发出了通知，JVM不一定会立刻执行，也就是说这句是无法确保此时JVM一定会进行垃圾回收的。
 
三、如何利用软引用和弱引用解决OOM问题
 
　　前面讲了关于软引用和弱引用相关的基础知识，那么到底如何利用它们来优化程序性能，从而避免OOM的问题呢？
 
　　下面举个例子，假如有一个应用需要读取大量的本地图片，如果每次读取图片都从硬盘读取，则会严重影响性能，但是如果全部加载到内存当中，又有可能造成内存溢出，此时使用软引用可以解决这个问题。
 
　　设计思路是：用一个HashMap来保存图片的路径 和 相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题。在Android开发中对于大量图片下载会经常用到。
 
　　下面这段代码是摘自博客：
 
　　http://blog.csdn.net/arui319/article/details/8489451
 
private Map<String, SoftReference<Bitmap>> imageCache = new HashMap<String, SoftReference<Bitmap>>();


    public void addBitmapToCache(String path) {


        // 强引用的Bitmap对象


        Bitmap bitmap = BitmapFactory.decodeFile(path);


        // 软引用的Bitmap对象


        SoftReference<Bitmap> softBitmap = new SoftReference<Bitmap>(bitmap);


        // 添加该对象到Map中使其缓存


        imageCache.put(path, softBitmap);


    }


    public Bitmap getBitmapByPath(String path) {


        // 从缓存中取软引用的Bitmap对象


        SoftReference<Bitmap> softBitmap = imageCache.get(path);


        // 判断是否存在软引用


        if (softBitmap == null) {


            return null;


        }


        // 取出Bitmap对象，如果由于内存不足Bitmap被回收，将取得空


        Bitmap bitmap = softBitmap.get();


        return bitmap;


    }
 
　　
 
当然这里我们把缓存替换策略交给了JVM去执行，这是一种比较简单的处理方法。复杂一点的缓存，我们可以自己单独设计一个类，这里面就涉及到缓存策略的问题了，具体可以参考之前的一篇博文：《缓存算法（页面置换算法）-FIFO、LFU、LRU》
 
　　参考资料：
 
　　《深入理解JVM虚拟机》
 
　　http://blog.csdn.net/arui319/article/details/8489451
 
　　http://blog.csdn.net/zsuguangh/article/details/6429592
 
　　http://mobile.51cto.com/abased-406998.htm
 
       作者：海子
 
       出处：http://www.cnblogs.com/dolphin0520/
 
       本博客中未标明转载的文章归作者海子和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。