• 内存泄露详细介绍

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

    什么是内存泄漏

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

    不是内存泄露:

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

    是内存泄露:

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

    内存泄露的理解:

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

    image.png

    垃圾回收不会回收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程序是一致的,则容器中的对象在程序结束之前将不能被释放,从而造成内存泄露.
    长生命周期对象持有短生命周期对象的引用,尽管短生命周期的对象不再使用,但是因为长生命周期对象持有它的引用而导致不能被回收

    image.png

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

    单例模式

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

    内部类持有外部类

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

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

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

    • 1

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

    变量不合理的作用域

    一个变量的定义的作用范围大于其使用范围,很有可能会造成内存泄露.另一方面,如果没有及时把对象设置为null,很有可能导致内存泄露的发生.
    image.png
    上面这个伪代码,通过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 +
                '}';
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71

    演示内存泄漏案例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 + '\'' +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57

    控制台输出结果:

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

    • 1

    上面的案例如果我不设置对象的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 + '\'' +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58

    控制台输出结果是

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

    • 1

    然后我又往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 + '\'' +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66

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

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67

    执行完毕控制台输出结果:
    可以发现触发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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    监听器和回调

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

  • 相关阅读:
    DevOps infra | 互联网、软件公司基础设施建设(基建)哪家强？
    Element中按键修饰符需要加.native
    第一章 Object-XML 映射简介
    Postman自动化测试实战：使用脚本提升测试效率
    ESP8266物联网套件学习
    Mozilla Firefox 浏览器
    java List remove方法
    鸿蒙：Harmony开发基础知识详解
    《2023中国企业数智化转型升级服务全景图/产业图谱2.0版》重磅发布
    JVM（Java虚拟机模型、Java运行时数据区模型）
  • 原文地址：https://blog.csdn.net/qq_41489540/article/details/126213220