java常见的内存泄漏

1. 基本理解

 

内存泄漏和内存溢出的关系：

1）内存泄漏

申请了内存用完了不释放，比如一共有1024M的内存，分配了512M的内存一直不回收，那么可以用的内存只有512M了，仿佛泄漏掉了一部分。

2）内存溢出

申请内存时，没有足够的内存可以使用。

泄漏的分类

经常发送：发送内存泄漏的代码会被多次执行，每次执行，泄漏一块内存

偶尔发送：在某些特定情况下才会发送

一次性：发送内存泄漏的方法只会执行一次

隐式泄漏：一直占着内存不释放，直到执行结果；严格的说这个不算内存泄漏，因为最终释放掉了，但是如果执行时间特别长，也可能会导致内存耗尽。

2 内存泄漏的8种情况

2.1 静态集合类

静态集合类，如HashMap、LinkedList等。如果这些容器为静态的，那么它们的生命周期与JVM程序一致，则容器中的对象在程序结束之前将不能被释放，从而造成内存泄漏。简单而言，长生命周期的对象持有短生命周期对象的引用，尽管短生命周期的对象不在使用，但是因为长生命周期对象持有它的引用而导致不能被回收。

public class MemoryLeak {
    static List list = new ArrayList();
​
    public void oomTests() {
        Object obj = new Object();
        list.add(obj);
    }
​
}

2.2 单例模式

单例模式，和静态集合导致内存泄漏的原因类似，因为单例的静态特性，它的生命周期和JVM的生命周期一样长，所以如果单例对象如果持有外部对象的引用，那么这个外部对象也不会被回收，那么就会造成内存泄漏。

2.3 内部持有外部类

内部类持有外部类，如果一个外部类的实例对象的方法返回了一个内部类的实例对象。

这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持有外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄漏。

2.4 各种连接

各种连接，如数据库连接、网络连接和IO连接等。

在对数据库进行操作的过程中，首先需要建立与数据库的连接，当不再使用时，需要调用close方法来释放对数据库的连接。只有连接被关闭后，垃圾回收器才会回收对应的对象。

否则，如果在访问数据库的过程中，对Connection、Statement或ResultSet不显性地关闭，将会造成大量的对象无法被回收，从而引起内存泄漏。

2.5 变量不合理的作用域

一般而言，一个变量的定义的作用范围大于其适用范围，很有可能会造成内存泄漏。另一方面，如果没有及时把对象设置为null，很有可能会导致内存泄漏的发送。

public class UsingRandom{
    private String msg;
    public void receiveMsg(){
        readFromNet();//从网络中接受数据保存到msg中
        saveDB();//把msg保存到数据库中
    }
}

如上面这个伪代码，通过readFromNet方法把接受的消息保存到变量msg中，然后调用saveDB方法把msg保存到数据库中。此时msg已经没用了，由于msg的生命周期与对象的生命周期相同，此时msg还不能回收，造成了内存泄漏。

实际上这个msg变量可以放到receiveMsg方法内部，当方法使用完，msg的生命周期也就结束，此时就可以回收了。还有一种方法，在使用完msg后，把msg设置为null。

2.6 改变哈希值

当一个对象被存储到HashSet集合中后，就不能修改这个对象中的那些参与计算哈希值的字段了。

否则，对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在contains方法使用该对象的当前引用作为参数去HashSet集合中索引对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，造成内存泄漏。

当我们想把自己定义的类保存到散列表的时候，需要保证对象的HashCode不可变。

public class ChangeHashCode {
    public static void main(String[] args) {
        HashSet set = new HashSet();
        Person p1 = new Person(1001, "AA");
        Person p2 = new Person(1002, "BB");
​
        set.add(p1);
        set.add(p2);
​
        p1.name = "CC";//导致了内存的泄漏
        set.remove(p1); //删除失败
​
        System.out.println(set);
​
        set.add(new Person(1001, "CC"));
        System.out.println(set);
​
        set.add(new Person(1001, "AA"));
        System.out.println(set);
​
    }
}
​
class Person {
    int id;
    String name;
​
    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
​
        Person person = (Person) o;
​
        if (id != person.id) return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }
​
    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }
​
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

2.7 缓存泄漏

内存泄漏的另一个常见来源是缓存，一旦你把对象引用放入到缓存中，他就很容易遗忘。

对于这个问题，可以使用WeakHashMap代表缓存，此种Map的特点是，当除了自身有对key的引用外，此key没有其它引用那么此map会自动丢弃此值。

public class MapTest {
    static Map wMap = new WeakHashMap();
    static Map map = new HashMap();
​
    public static void main(String[] args) {
        init();
        testWeakHashMap();
        testHashMap();
    }
​
    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, "cacheObject1");
        wMap.put(ref2, "cacheObject2");
        map.put(ref3, "cacheObject3");
        map.put(ref4, "cacheObject4");
        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(5);
        } catch (InterruptedException e) {
            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(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("HashMap GC之后");
        for (Object o : map.entrySet()) {
            System.out.println(o);
        }
    }
​
}
/**
 * 结果
 * String引用ref1，ref2，ref3，ref4 消失
 * WeakHashMap GC之前
 * obejct2=cacheObject2
 * obejct1=cacheObject1
 * WeakHashMap GC之后
 * HashMap GC之前
 * obejct4=cacheObject4
 * obejct3=cacheObject3
 * Disconnected from the target VM, address: '127.0.0.1:51628', transport: 'socket'
 * HashMap GC之后
 * obejct4=cacheObject4
 * obejct3=cacheObject3
 **/

2.8 监听器和回调

内存泄漏另一个常见来源是监听器和其它回调，如果客户端在你实现的API中注册回调，却没有显示的取消，那么就会积聚。

需要确保回调立即被当作垃圾回收的最佳方法是只保存它的弱引用，例如将他们保存成为WeakHashMap中的键。