消除过期的对象引用的理解

什么是过期的对象引用？

我们通过简单的栈实现来引入过期的对象引用。

public class Stack {    private Object[] elements;    private int size = 0;    private static final int DEFAULT_INITIAL_CAPACITY = 16;    public Stack(){        elements = new Object[DEFAULT_INITIAL_CAPACITY];    }    public void push(Object e){        ensureCapacity();        elements[size ++] = e;    }    public Object pop(){        if (size == 0){            throw new EmptyStackException();        }        return elements[--size];    }    private void ensureCapacity(){        if (elements.length == size){            elements = Arrays.copyOf(elements, 2 * size + 1);        }    }}

实际上，这段程序中并没有很明显的错误。无论如何测试，它都会成功地运行通过每一项测试，但这个程序中隐藏着一个问题。不严格地讲，这段程序有一个”内存泄漏“， 随着垃圾回收器活动的增加，或者由于内存占用的不断增加，程序性能的降低会逐渐表现出来。在极端的情况下，这种内存泄露会导致磁盘交换，甚至程序失败，但这种情况比较少见。

那么，程序中哪里发生了内存泄漏呢?实际上，当栈先增长后收缩时，即使我们执行push后再pop，这时候弹出来的对象将不会被当作垃圾回收，即便使用栈的程序不会再引用这些对象，也不会被回收。因为栈内部维护着这些对象的过期引用。

过期引用：指的是永远不会再被解除的引用。

在我们的stack例子中，凡是在elements数组的”活动范围“之外的任何引用都是过期的，这里的活动部分指的是elements中下标小于size的那些元素。

如何解决stack中的过期引用问题？
实际上，一旦对象引用已经过期，只需清空这些引用即可。

public Object pop(){        if (size == 0){            throw new EmptyStackException();        }        Object result = elements[--size];        //清空引用        elements[size] = null;        return result;    }

那么可不可以理解为，当对象引用过期了，直接设置为null即可。
我们再看一个例子：

List<String> list = new ArrayList<>();String str = "java";list.add(str);str  = null;

那么通过上面的方法，创建str的内存空间是否就被回收了呢？实际上，并没有，list依然持有对str的引用，所以创建str时的内存空间是不会被回收的。对于这种引用，我们称为”无意识的内存引用“。

为了更好地解决”无意识的内存引用“问题，我们先要明白对象间相互依赖是怎么样的？

Object object1 = new Object();Object object2 = object1;Object object3 = object2;

其对应的引用图如下：

Paste_Image.png

因此，如果我们要回收Object1所创建的内存空间的话，单纯地设置object1 = null是无法回收的，因为object2和object3都保留着对内存的引用。

因此，要消除 ”无意识的引用“ 必须删除掉所有对内存空间的引用。

那么对于之前的list的例子，我们可以通过list.remove(str)或者list = null方法来删除对空间的引用，从而使得垃圾回收器可以回收到该内存空间。

为了更好地解决问题，我们要先弄清楚两个关键字：Java的垃圾回收机制 和 Java的内存泄漏

Java的垃圾回收机制：

Java中的对象是在堆中分配，对象的创建有2中方式：new或者反射。对象的回收是通过垃圾收集器，JVM的垃圾收集器简化了程序员的工作，但是却加重了JVM的工作，这是Java程序运行稍慢的原因之一，因为GC为了能正确释放对象，必须监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等，GC都要进行监控，监控对象的状态是为了更加准确、及时地释放对象，而释放对象的根本原则就是该对象不再被引用。

---

Java的内存泄漏：

• 什么是内存泄漏？
  对象已经没有被应用程序使用，但是垃圾回收器没办法移除它们，因为还在被引用着。

• 为何会产生内存泄漏？
  Java有垃圾回收机制，那么还存在内存泄露吗？答案是肯定的，所谓的垃圾回收GC会自动管理内存的回收，而不需要程序员每次都手动释放内存，但是如果存在大量的临时对象在不需要使用时并没有取消对它们的引用，就会吞噬掉大量的内存，很快就会造成内存溢出。

内存泄漏的几种情形：

a. 类是自己管理内存的，比如我们上面所举的stack的例子，对于这种情况，一旦元素被释放掉了，则该元素中包含的任何对象引用都应该被清空。

b. 内存泄漏的另一个常见来源是缓存。一旦你把对象引用放到缓存中，它就很容易被遗忘掉，从而使得它不再有用之后很长一段时间内仍然留在缓存中。解决方法是使用WeakHashMap

c. 内存泄漏的第三个常见来源是监听器和其他回调。如果你实现了一个API，客户端在这个API中注册调用，却没有显式地取消注册，那么除非你采取某些措施，否则它们就会积聚。解决方法为确保回调立即当作垃圾回收的最佳方法是只保存它们的弱引用。

作者：大海孤了岛
链接：http://www.jianshu.com/p/65d413287090

Java的垃圾回收机制并不代表我们不需要考虑内存管理的问题。

 

考虑：

public class Stack {    pprivate Object[] elements;    private int size = 0;    private static final int DEFAULT_INITAL_CAPACITY = 16;        public Stack() {        elements = new Object[DEFAULT_INITAL_CAPACITY];    }        public void push(Object e) {        ensureCapacity();        elements[size++] = e;    }        public Object pop() {        if(size == 0) {            throw new EmptyStackException();        }        return elements[--size];    }        private void ensureCapacity() {        if(elements.length == size)            elements = Arrays.copyOf(elements, 2 * size + 1);    }}

这是自己编写的一个栈。

这段程序没有任何明显的错误，但这个程序中隐藏着一个问题，内存泄漏。

如果一个栈先是增长，然后收缩，那么从栈中弹出来的对象不会被当作垃圾回收，这是因为栈内部仍然维护着这些过期对象的引用，所谓过期引用是指elements中下标大于等于size的那些元素（由于栈会增长收缩，所以这是完全有可能的），如果一个对象被无意识地（即我们不希望地）保留下来，那么这个引用所引用的其他对象也不会被垃圾回收机制回收，因为仍然存在着引用，GC认为这些对象仍然是会被使用的。随着程序的运行时间增长，过期的对象引用占用的内存会越来越大，导致程序性能下降。

 

这类问题的解决方法是：一旦对象引用已经过期，只需清空这些引用即可。

public Object pop() {        if(size == 0) {            throw new EmptyStackException();        }        Object result = elements[--size];        elements[size] = null;//显式地清空引用        return result;}

清空对象引用应该是一种例外，而不是一种规范行为，不要求也不建议程序员对于每个对象引用，一旦程序不再用，就把它清空，这通常会把代码弄的很混乱。

消除过期引用的最好办法是在最紧凑的作用域范围内定义每一个变量，当作用域被执行完，GC会自动把过期作用域的变量回收掉。

 

什么时候应该自己清空引用？

一般而言，只要是自己管理内存，就应该警惕内存泄漏问题。假如你开辟了一段内存空间，并一直持有这段空间的引用，就有责任管理它，因为GC无法自动完成对你承诺管理的内存的回收，除非你告诉它（显式地清空引用）。

 

在JDK中，已经有现成的Stack类供我们使用，来看看它是怎么实现pop的：

public synchronized E pop() {        E       obj;        int     len = size();        obj = peek();//这个方法将栈顶的元素取出来，但并不会把栈顶元素弹出        removeElementAt(len - 1);//这是Stack父类的方法,将栈顶元素弹出        return obj;}public synchronized void removeElementAt(int index) {        modCount++;        if (index >= elementCount) {            throw new ArrayIndexOutOfBoundsException(index + " >= " +                                                     elementCount);        }        else if (index < 0) {            throw new ArrayIndexOutOfBoundsException(index);        }        int j = elementCount - index - 1;        if (j > 0) {            System.arraycopy(elementData, index + 1, elementData, index, j);        }        elementCount--;        elementData[elementCount] = null; /* to let gc do its work *//可以看到，jdk的实现就是显式地把引用清空，以此告诉GC将过期引用回收}

 

内存泄泄漏通常不会表现成明显的失败，可以在系统中存在很多年，只有通过检查代码，或借助Heap剖析工具才能发现内存泄漏问题。所以要尽量在内存泄漏发生之前就知道如何预测此类问题。