Go语言视频零基础入门到精通

javalearner

java向程序员许下了一个美好的承诺：JAVA程序员无需关心内存释放的问题，JVM的垃圾回收机制会自动回收无用对象所占用的内存空间，这易产生一个错觉：JAVA程序不会有内存泄漏。但实际上，如果使用不当，
JAVA程序一样会有内存泄漏的问题存在。


例：

1.    public class Stack
   
2. {
   
3.         //存放栈内元素的数组
   
4.         private Object[] elementData;
   
5.         //记录栈内元素的个数
   
6.         private int size = 0;
   
7.         private int capacityIncrement;
   
8.         //以指定初始化容量创建一个Stack
   
9.         public Stack(int initialCapacity)
   
10.         {
    
11.                 elementData = new Object[initialCapacity];
    
12.         }
    
13.         public Stack(int initialCapacity , int capacityIncrement)
    
14.         {
    
15.                 this(initialCapacity);
    
16.                 this.capacityIncrement = capacityIncrement;
    
17.         }
    
18.         //向“栈”顶压入一个元素
    
19.         public void push(Object object)
    
20.         {
    
21.                 ensureCapacity();
    
22.                 elementData[size++] = object;
    
23.         }
    
24.         public Object pop()
    
25.         {
    
26.                 if(size == 0)
    
27.                 {
    
28.                         throw new RuntimeException("空栈异常");
    
29.                 }
    
30.                 return elementData[--size];
    
31.         }
    
32.         public int size()
    
33.         {
    
34.                 return size;
    
35.         }
    
36.         //保证底层数组能容纳栈内所有元素
    
37.         private void ensureCapacity()
    
38.         { //增加堆栈的容量
    
39.                 if(elementData.length==size)
    
40.                 {
    
41.                         Object[] oldElements = elementData;
    
42.                         int newLength = 0;
    
43.                         //已经设置capacityIncrement
    
44.                         if (capacityIncrement > 0)
    
45.                         {
    
46.                                 newLength = elementData.length + capacityIncrement;
    
47.                         }
    
48.                         else
    
49.                         {
    
50.                                 //将长度扩充到原来的1.5倍
    
51.                                 newLength = (int)(elementData.length * 1.5);
    
52.                         }
    
53.                         elementData = new Object[newLength];
    
54.                         //将原数组的元素复制到新数组中
    
55.                         System.arraycopy(oldElements , 0 , elementData , 0 , size);
    
56.                 }
    
57.         }
    
58.         public static void main(String[] args)
    
59.         {
    
60.                 Stack stack = new Stack(10);
    
61.                 //向栈顶压入10个元素
    
62.                 for (int i = 0 ; i < 10 ; i++)
    
63.                 {
    
64.                         stack.push("元素" + i);
    
65.                 }
    
66.                 //依次弹出10个元素
    
67.                 for (int i = 0 ; i < 10 ; i++)
    
68.                 {
    
69.                         System.out.println(stack.pop());
    
70.                 }
    
71.         }
    
72. }
    

复制代码

上面程序实现了一个简单的Stack,并为这个Stack实现了push(),pop()两个方法，其中pop()方法可能产生内存泄漏。程序main方法创建了一个Stack对象，先压入10个元素，此时底层elementData数组的长度为10，每个数组元素都引用一个字符串。
接下来，程序10次调用pop()弹出栈顶元素，它只做了两件事：
1、修改了Stack的size属性，也就是记录栈内元素减1；
2、返回clementData数组中索引为size-1的元素，但并未清除elementData数组最后一个元素的引用，这样就会产生内存泄漏。

1. 应修改为：
   
2. public Object pop()
   
3.         {
   
4.                 if(size == 0)
   
5.                 {
   
6.                         throw new RuntimeException("空栈异常");
   
7.                 }
   
8.                 Object ele=elementData[--size];
   
9.                 //清除elementData数组最后一个元素的引用
   
10.                elementData[size]=null;
    
11.               return ele;
    
12.         }
    

复制代码