java程序员--当心你代码中的内存泄漏

当你从c&c++转到一门具备垃圾回收功能的语言时，程序员的工做就会变得更加容易，由于你用完对象，他们会被自动回收，可是，java程序员真的不须要考虑内存泄露吗？ 其实否则

1.举个例子-看你可否找出内存泄漏

import java.util.Arrays;

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

1.1缘由分析

上述程序并无明显的错误，可是这段程序有一个内存泄漏，随着GC活动的增长，或者内存占用的不断增长，程序性能的下降就会表现出来，严重时可致使内存泄漏，可是这种失败状况相对较少。
代码的主要问题在pop函数，下面经过这张图示展示
假设这个栈一直增加，增加后以下图所示

当进行大量的pop操做时，因为引用未进行置空，gc是不会释放的，以下图所示

从上图中看以看出，若是栈先增加，在收缩，那么从栈中弹出的对象将不会被看成垃圾回收，即便程序再也不使用栈中的这些队象，他们也不会回收，由于栈中仍然保存这对象的引用，俗称过时引用，这个内存泄露很隐蔽。

1.2解决方法

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

一旦引用过时，清空这些引用，将引用置空。

2.缓存泄漏

内存泄漏的另外一个常见来源是缓存，一旦你把对象引用放入到缓存中，他就很容易遗忘，对于这个问题，能够使用WeakHashMap表明缓存，此种Map的特色是，当除了自身有对key的引用外，此key没有其余引用那么此map会自动丢弃此值

2.1代码示例

/**
 * Created by liuroy on 2017/2/25.
 */
import java.util.HashMap;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.TimeUnit;

public class Test {
    static Map wMap = new WeakHashMap();
    static Map map = new HashMap();
    public static void init(){
        String ref1= new String("obejct1");
        String ref2 = new String("obejct2");
        String ref3 = new String ("obejct3");
        String ref4 = new String ("obejct4");
        wMap.put(ref1, "chaheObject1");
        wMap.put(ref2, "chaheObject2");
        map.put(ref3, "chaheObject3");
        map.put(ref4, "chaheObject4");
        System.out.println("String引用ref1，ref2，ref3，ref4 消失");

    }
    public static void testWeakHashMap(){

        System.out.println("WeakHashMap GC以前");
        for (Object o : wMap.entrySet()) {
            System.out.println(o);
        }
        try {
            System.gc();
            TimeUnit.SECONDS.sleep(20);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("WeakHashMap GC以后");
        for (Object o : wMap.entrySet()) {
            System.out.println(o);
        }
    }
    public static void testHashMap(){
        System.out.println("HashMap GC以前");
        for (Object o : map.entrySet()) {
            System.out.println(o);
        }
        try {
            System.gc();
            TimeUnit.SECONDS.sleep(20);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("HashMap GC以后");
        for (Object o : map.entrySet()) {
            System.out.println(o);
        }
    }
    public static void main(String[] args) {
        init();
        testWeakHashMap();
        testHashMap();
    }
}
/** 结果
String引用ref1，ref2，ref3，ref4 消失
WeakHashMap GC以前
obejct2=chaheObject2
obejct1=chaheObject1
WeakHashMap GC以后
HashMap GC以前
obejct4=chaheObject4
obejct3=chaheObject3
Disconnected from the target VM, address: '127.0.0.1:51628', transport: 'socket'
HashMap GC以后
obejct4=chaheObject4
obejct3=chaheObject3
**/

上面代码和图示主演演示WeakHashMap如何自动释放缓存对象，当init函数执行完成后，局部变量字符串引用weakd1,weakd2,d1,d2都会消失，此时只有静态map中保存中对字符串对象的引用，能够看到，调用gc以后，hashmap的没有被回收，而WeakHashmap里面的缓存被回收了。

监听器和回调

内存泄漏第三个常见来源是监听器和其余回调，若是客户端在你实现的API中注册回调，却没有显示的取消，那么就会积聚。须要确保回调当即被看成垃圾回收的最佳方法是只保存他的若引用，例如将他们保存成为WeakHashMap中的键。