浅谈Java--内存泄漏

阅读更多

      JAVA的垃圾回收机制，让许多程序员觉得内存管理不是很重要，但是内存内存泄露的事情恰恰这样的疏忽而发生，特别是对于Android开发，内存管理更为重要，养成良好的习惯，有利于避免内存的泄漏.

 

对象的几种状态：

    这里可以把许多对象和引用看成是有向图，顶点可以是对象也可以是引用，引用关系就是有向边。

1. 可达状态：对象创建的时候，有引用指向它，这个时候在对象和引用之间建立了引用关系，即由引用发射有向边指向对象，这个对象就是出于可达状态
2. 可恢复状态：当引用不指向一个对象的时候，该对象就处于可恢复状态，这时候在系统回收该对象之前，会调用finalize方法进行资源清理，如果调用这个方法后能重新让引用变量去引用他，那么他又恢复到可达状态，不然会变成不可达状态。
3. 不可达状态：当对象和引用变量失去了引用关系，并且调用了finalize方法后，不能恢复到可达状态，那么将永久性失去引用，此时系统才会真正去回收对象占用的内存。

 

 

何为内存泄漏：

    内存泄漏就是程序运行中，java垃圾回收机制，会对一些不适用的内存进行回收，然后再重新分配，保证系统能再次用到这些内存，Java中所有不可达状态都会被回收，但是一些处于可达状态，但是程序却再也不会用到的对象（占着茅坑不拉屎），这些内存就无法被回收，他们对于程序员来说已经没用，但是对于垃圾回收机制来说，他们是可达的，所以是“有用的”这些占用的内存就会出现内存泄漏。

 

 用一个栈的例子说明：

package CrazyJava;
import javax.management.RuntimeErrorException;
/**
 * 
 * @author ccf
 *
 */
public class neicun {
     /**
     * @param args
     */
     class Stack {
         private Object[] elementData;
         private int size;
         private int capacityIncrement;
         public Stack( int initialCapacity) {
            elementData = new Object[initialCapacity];
        }
         public Stack( int initialCapacity, int capacityIncrement) {
            elementData = new Object[initialCapacity];
             this.capacityIncrement = capacityIncrement;
        }
         public void push(Object object) {
            ensureCapacity();
            elementData[size ++] = object; // 后加
        }
         public Object pop() {
             if (size == 0)
                 throw new RuntimeException( "空栈异常");
            Object ele = elementData[ --size]; // 这里为局部变量，当方法结束，局部变量会被回收
            elementData[size] = null; // 消去强引用关系，避免产生内泄漏。
             return ele; // 返回栈顶元素 size自减1个长度
        }
         public int size() {
             return size;
        }
         private void ensureCapacity() {
             // TODO Auto-generated method stub
             // 数组已经满了。进行扩容。
             if (elementData.length == size) {
                Object[] oldElmentata = elementData;
                 int newLength = 0;
                 if (capacityIncrement > 0) {
                    newLength = elementData.length + capacityIncrement;
                } else {
                    newLength = ( int) (elementData.length * 1. 5);
                }
                elementData = new Object[newLength];
                System.arraycopy(oldElmentata, 0, elementData, 0, size);
            }
        }
    }
     public static void main(String[] args) {
         // TODO Auto-generated method stub
        Stack stack = new neicun(). new Stack( 10);
         for ( int i = 0; i < 10; i ++) {
            stack.push( "元素" + i);
        }
         for ( int i = 0; i < 10; i ++) {
            System.out.println(stack.pop());
        }
    }
}

 

 

代码中pop() 函数实现出栈，其中  elementData[size] = null; 切断了元素和其引用的引用关系，这样可以使元素进入不可达状态，从能被系统回收，如果不切断引用，该元素将一直可以可达状态，就会常驻内存。

而针对上一句Object ele = elementData[ --size];   就是为了暂存这个元素，用于作为return的返回值，有人会问这个为什么不会造成内存泄露，他们之间不是已经有了引用和被引用的关系，原因是这里的Object对象是局部变量，局部变量的生命周期跟方法生命周期一样，该方法结束了，搞局部变量会被垃圾回收机制收回，所以这个担心是没必要的。

 

 

         从以上看来，内存泄漏可能性还是很大的，强引用类型（以后的博文会讲）使我们用得最多的类型，这类引用只有再失去引用的时候才会被回收，其他情况都是不能被回收的，所以良好的编程习惯是避免内存泄漏的好办法

 

 

 

  怎样避免内存泄漏：

1. 尽量多使用直接量    
   例如String类型 
   String a =“ccf”  //采用直接量，JVM字符串池会缓存这个字符串
   String b = new String（“ccf”）； //但是直接调用构造方法的话，因为String内部是基于数组，所以会产生 字符数组存储ccf三个字符。
2. 多使用StringBuilder和StringBuffer
   使用StringBuilder和StringBuffer进行字符串的操作，可以减少使用String进行字符串操作产生的临时字符串
3. 释放无用的对象引用，就像上面栈的 pop （）方法
4. 少用静态变量，静态变量生命周期跟类一样，为类加载到类卸载这段时间，也就是知道程序结束。
5. 避免在循环和经常调用的方法创建对象，因为这些情况会产生大量对象，特别是像for循环这些。
6. 缓存经常用到的对象，避免重复去创建相同对象，想android中Adapter中重写getView就经常用到对象缓存技术。