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

什么是过期的对象引用？

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

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中注册调用，却没有显式地取消注册，那么除非你采取某些措施，否则它们就会积聚。解决方法为确保回调立即当作垃圾回收的最佳方法是只保存它们的弱引用。

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);
    }
}

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

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将过期引用回收
}