学习 尚硅谷 宋红康 JVM从入门到精通 的学习笔记

什么是内存泄漏

可达性分析算法来判断对象是否是不再使用的对象,本质都是判断一个对象是否还被引用.那么对于这种情况下,由于代码的实现不同就会出现多种内存泄露的问题(让JVM误以为这个对象还在引用中,无法回收,造成了内存的泄露)

不是内存泄露:

• 是否还被使用? 是
• 是否还被需要? 是

是内存泄露:

• 是否还被使用? 是
• 是否还被需要? 不需要

内存泄露的理解:

只有对象不会被程序用到了,但是GC又不能回收他们的情况,才叫内存泄漏.
实际情况很多时候一些不太好的编码习惯,或者疏忽情况,会导致对象的生命周期变得很长(始终回收不了)甚至导致OOM,也可以叫做宽泛意义上的 内存泄露 .

垃圾回收不会回收Y对象,因为Y对象被X对象引用,这个我们也可以当做是内存泄露的问题.上图中X对象也调用了A和B和C,这样X不被垃圾回收的话, A B C 三个对象也会被引用导致不能被回收掉, 这个也可以理解为是内存泄漏.

内存泄露和内存溢出的关系:

1.内存泄露(memory leak):
申请完了内存用完了不释放,比如说一共有1024M的内存,分片了512M的内存一直不回收,那么可以用的内存只有512M了,仿佛泄露掉了一部分;
通俗一点讲,内存泄露就是 占着茅坑不拉屎
2.内存溢出(out of memory)
申请内存时,没有足够的内存可以使用;
就好比一个餐厅三张桌子,有两组游客吃完饭不走(内存泄露),剩下最后一张桌子,餐厅表示接待压力很大,这个时候一下子来了两组游客吃饭,此时只有一张桌子了,内存泄露就变成了内存溢出了.

内存泄露和内存溢出的关系:
内存泄露的增多了,最终会导致内存溢出.

泄露的分类:

经常发生: 发生内存泄露的代码会被多次执行,每次执行这次代码,就会触发内存泄露,我们需要规避这个问题.
偶然发生: 在某些特定情况下才会发生,比如说资源的关闭,忘了关闭数据库连接,io流忘了关闭等等.
一次性: 发生内存泄露的方法只会执行一次.这种还好一点,只要占用的资源别太大的话,还可以容忍
隐式泄漏:一直占着内存不释放,直到执行结束,严格来说这个不算内存泄漏,因为最终释放掉了,但是如果执行时间特别长,也可能会导致内存的耗尽,

内存泄露的八种情况

静态集合类

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

obj是在oomTests方法里面创建的,但是add到list里面了, list是静态的,list如果不被回收的话,那么obj也不会被回收.这样就会出现内存的泄露

单例模式

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

内部类持有外部类

内部类持有外部类,如果一个外部类的实例对象返回了一个内部类的实例对象,
这个内部类对象被长期引用了,即使那个外部类实例对象不再使用了,但是由于内部类持有外部类的实例对象,这个外部类对象将不会被垃圾回收,这个也会造成内存泄露的问题.

各种连接,如数据库连接,网络连接,IO连接等等

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

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

变量不合理的作用域

一个变量的定义的作用范围大于其使用范围,很有可能会造成内存泄露.另一方面,如果没有及时把对象设置为null,很有可能导致内存泄露的发生.

上面这个伪代码,通过readFromNet方法把接受的消息保存在变量msg中,然后调用saveDB方法把msg的内容保存到数据库中,此时msg已经没用了,由于msg的生命周期和对象的生命周期系统,此时msg还不能被回收,因此造成内存泄露
解决办法:
msg变量可以挡在receiveMsg方法里面,当方法执行完,msg的生命周期就结束了,此时就可以被回收了.
还有一种办法是,使用完msg后,把msg设置为null,这样垃圾回收器也会回收msg的内存空间.

改变哈希值

当一个对象被存储进HashSet集合中以后,就不能修改这个对象中的那些参与计算哈希值的字段了.
否则,对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了,在这种情况下,即使在contains方法中使用这个对象的当前引用作为的参数去HashSet集合中检索对象,也将返回找不到对象的结果,这也会导致无法从HashSet集合中单独删除当前对象,造成内存泄漏.
这也是String为什么被设置成不可变类型,我们可以放心的把String存入HashSet,或者把String当做HashMap的key值.

演示内存泄漏案例1:

import java.util.HashSet;

/**
 * 演示内存泄漏
 */
public class ChangeHashCode1 {
    
    public static void main(String[] args) {
    
        HashSet<Point> hs = new HashSet<Point>();
        Point cc = new Point();
        cc.setX(10);//此时hashCode = 41
        hs.add(cc);

        cc.setX(20);//此时hashCode = 51  此行为导致了内存的泄漏

        /*删除数据也需要通过hash值去找位置,存的时候hashCode值是41,
          但是我setX之后,hashCode的值是51,我又把这个hashCode值为51的值存到HashSet里面,
          此时hashCode值是新的值为51,那么那个hashCode值为41的值没有被覆盖掉,就会一直被HashSet引用而无法回收掉.
         */
        System.out.println("hs.remove = " + hs.remove(cc));//false
        /* 虽然你是一个对象,此时你又add了一次,因为hashCode值不一样,虽然是add是一个对象,但是后面add的对象没有把前面覆盖掉
           结果就是往HashSet里面添加了两个对象
        */
        hs.add(cc);
        System.out.println("hs.size = " + hs.size());//size = 2

        System.out.println(hs);

        // 输出结果: [Point{x=20}, Point{x=20}]  
        //上面的结果你会发现虽然是一个对象但是被设置进去两个值.

    }

}

class Point {
    
    int x;

    public int getX() {
    
        return x;
    }

    public void setX(int x) {
    
        this.x = x;
    }

    @Override
    public int hashCode() {
    
        final int prime = 31;
        int result = 1;
        result = prime * result + x;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
    
        if (this == obj) return true;
        if (obj == null) return false;
        if (getClass() != obj.getClass()) return false;
        Point other = (Point) obj;
        if (x != other.x) return false;
        return true;
    }

    @Override
    public String toString() {
    
        return "Point{" +
                "x=" + x +
                '}';
    }
}

演示内存泄漏案例2:

import java.util.HashSet;

/**
 * 演示内存泄漏
 */
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);
        //输出结果:[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
    }
}

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 + '\'' +
                '}';
    }
}

控制台输出结果:

[Person{
    id=1002, name='BB'}, Person{
    id=1001, name='CC'}]

上面的案例如果我不设置对象的name值的话, p1.name = “CC” 这个代码我不去操作,我去掉

import java.util.HashSet;

/**
 * 演示内存泄漏
 */
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);
        //输出结果:[Person{id=1002, name='BB'}]

    }
}

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 + '\'' +
                '}';
    }
}

控制台输出结果是

[Person{
    id=1002, name='BB'}]

然后我又往HashSet里面添加两个Person对象: new Person(1001, “CC”) new Person(1001, “AA”)
下面代码查看结果:

import java.util.HashSet;

/**
 * 演示内存泄漏
 */
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);
        //输出结果:[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]

        set.add(new Person(1001, "CC"));
        System.out.println(set);
        //输出结果:[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}]

        set.add(new Person(1001, "AA"));
        System.out.println(set);
        //输出结果: [Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}, Person{id=1001, name='AA'}]
    }
}

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 + '\'' +
                '}';
    }
}

往HashSet里面插入new Person(1001, “CC”) 的时候,虽然HashSet里面已经有了[Person{id=1002, name=‘BB’}, Person{id=1001, name=‘CC’}],但是因为HashSet里面已经存在的Person{id=1001, name=‘CC’}对象,这个已经存在的对象是通过修改值进去的,后面新添加的值没有办法跟已经存在的Person{id=1001, name=‘CC’}比较,因为HashSet已经存在的Person{id=1001, name=‘CC’}值是通过Person{id=1001, name=‘AA’}的值修改的.
后面又添加了new Person(1001, “AA”),这个能正常进去了,原因是最初的HashSet有个new Person(1001, “AA”)对象,两个哈希code值是一样的,但是进行equals的时候又发现具体的值不一样,就用了链表指针,进行连接都放进去了

缓存泄露

内存泄露的另外一个常见来源是缓存,一旦你把对象放到缓存当中,就很容易忘掉,比如说,项目在一次上线的时候,应用启动比较慢,直到卡死.就是因为代码中会加载一个表中的数据到内存里面,当时测试环境只有几百条数据,但是生产环境有几百万的数据.
对于这个问题,我们可以使用WeakHashMap这种弱引用Map来代替缓存,WeakHashMap的特点是,当除了自身有对key的引用外,这个key没有其它引用那么这个WeakHashMap会自动丢弃这个值.

案例

import java.util.HashMap;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.TimeUnit;

/**
 * 演示内存泄漏
 */
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);
        }
    }

}

执行完毕控制台输出结果:
可以发现触发GC之后,WeakHashMap的里面的数据没有被除了自身之外别的对象引用的话,就会被清理掉

String引用ref1，ref2，ref3，ref4 消失
WeakHashMap GC之前
obejct2=cacheObject2
obejct1=cacheObject1
WeakHashMap GC之后
HashMap GC之前
obejct4=cacheObject4
obejct3=cacheObject3
HashMap GC之后
obejct4=cacheObject4
obejct3=cacheObject3

监听器和回调

内存泄露的第三个常见来源是监听器和其他回调,如果客户端在你实现的API中注册回调,缺没有显示的取消,那么就会积聚.
需要确保回调立即被当做垃圾回收的最佳方法是只保存它的弱引用,例如将他们保存成为WeakHashMap中的键.