讨论下面这个程序在jdk1.5下是否真的有内存泄露

Question

import java.util.EmptyStackException;public class Stack
{
    
    /**
     * Field elements.
     */
    private Object[] elements = new Object[10];
    
    /**
     * Field size.
     */
    private int size = 0;
    
    /**
     * Method push.
     * @param e Object
     */
    public void push(Object e)
    {
        ensureCapacity();
        elements[size++] = e;
    }
    
    /**
     * Method pop.
     * @return Object
     */
    public Object pop()
    {
        if (size == 0)
            throw new EmptyStackException();
        return elements[--size];
    }
    
    /**
     * Method ensureCapacity.
     */
    private void ensureCapacity()
    {
        if (elements.length == size)
        {
            Object[] oldElements = elements;
            elements = new Object[2 * elements.length + 1];
            System.arraycopy(oldElements, 0, elements, 0, size);
        }
    }
    
    /**
     * Method main.
     * @param args String[]
     */
    public static void main(String[] args)
    {
        Stack stk = new Stack();
        
        while (true)
        {
            Object o = new Object();
            for (int i = 0; i < 10000; i++)
            {
                stk.push(o);
                
            }
            for (int i = 0; i < 10000; i++)
            {
                stk.pop();
                
            }
            
        }
        
    }
}

Answer 1

就是这段代码有没有内存泄露。按照一般的说法，elements 保留了对Object的引用。public Object pop() 
    { 
        if (size == 0) 
            throw new EmptyStackException(); 
      return elements[--size]; 
    } 

Answer 2

java应该不会有一般意义上的内存泄漏的吧。。

Answer 3

你是指arraycop()后，原来的那个数组仍然包含着object的引用？

Answer 4

有啊public Object pop()
    {
        if (size == 0)
            throw new EmptyStackException();
      return elements[--size];
    } 应该先设置为nullObject r = elements[--size];
elements[size] ＝ null;
return r;为什么你要说在jdk 5以下呢？

Answer 5

可以试一下，使用jprofiler等测试不出有泄露。内存可以回收。

Answer 6

我觉得这样做，并不叫内存泄露，而是压根就没有释放，所谓内存泄露，是指那些应用或者操作系统压根无法回收的内存。
而pop这样做的话，只是返回elements中的对象，却没有去掉elements对pop出对象的引用，所以，这些对象的空间暂时还是被程序占用，
但将来再PUSH其它对象的时候，栈中旧的对象自然就会变成可释放状态，
所以，我觉得使用这个结果，基本上不会有太大问题（应该和JDK版本也没有太大关系）。你可以做个试验，如果向其中push大量的数据（比如：100万个，目的是占用大量内存），然后再都pop处理，应该会发现，内存还是保存最高值，而没有释放。
但我认为这不算内存泄露，只能说程序设计不合理罢了。

Answer 7

设计不合理，根据使用场景，可能会内存泄漏。
例如，如果该栈是一个全局性的，这时因为pop时没有清空引用，则当栈中的对象已经没有用处时，本应该被虚拟机回收，但由于栈占用了引用，则就会发生内存泄漏。
与jdk版本无关。