什么是内存泄漏

可达性分析算法来判断对象是否是不再使用的对象,本质都是判断一个对象是否还被引用.那么对于这种情况下,由于代码的实现不同就会出现多种内存泄露的问题(让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连接等等

  1. 在对数据库进行操作的过程中,首先需要建立和数据库的连接,当不再使用的时候,需要调用close方法来释放和数据库的连接,只有连接被关闭后,垃圾回收器才会回收对应的对象.<br />  否则,如果在访问数据库的过程中,对Connection, Statement或者ResultSet不显性的关闭,将会造成大量的对象无法被回收,从而引起内存泄露.<br />  ![image.png](https://cdn.nlark.com/yuque/0/2022/png/350923/1659260298963-84798ba7-d3bd-4d45-bf9c-3a31c46c5468.png#clientId=u54e3d6dc-30f6-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=341&id=u65f8934c&margin=%5Bobject%20Object%5D&name=image.png&originHeight=341&originWidth=580&originalType=binary&ratio=1&rotation=0&showTitle=false&size=163226&status=done&style=none&taskId=u7bc8e598-cbb7-4014-8c30-6a021f28129&title=&width=580)

变量不合理的作用域

一个变量的定义的作用范围大于其使用范围,很有可能会造成内存泄露.另一方面,如果没有及时把对象设置为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:

  2. import java.util.HashSet;
  4. /**
  5.  * 演示内存泄漏
  6.  */
  7. public class ChangeHashCode1 {
  8.     public static void main(String[] args) {
  9.         HashSet<Point> hs = new HashSet<Point>();
  10.         Point cc = new Point();
  11.         cc.setX(10);//此时hashCode = 41
  12.         hs.add(cc);
  14.         cc.setX(20);//此时hashCode = 51  此行为导致了内存的泄漏
  16.         /*删除数据也需要通过hash值去找位置,存的时候hashCode值是41,
  17.           但是我setX之后,hashCode的值是51,我又把这个hashCode值为51的值存到HashSet里面,
  18.           此时hashCode值是新的值为51,那么那个hashCode值为41的值没有被覆盖掉,就会一直被HashSet引用而无法回收掉.
  19.          */
  20.         System.out.println("hs.remove = " + hs.remove(cc));//false
  21.         /* 虽然你是一个对象,此时你又add了一次,因为hashCode值不一样,虽然是add是一个对象,但是后面add的对象没有把前面覆盖掉
  22.            结果就是往HashSet里面添加了两个对象
  23.         */
  24.         hs.add(cc);
  25.         System.out.println("hs.size = " + hs.size());//size = 2
  27.         System.out.println(hs);
  29.         // 输出结果: [Point{x=20}, Point{x=20}]  
  30.         //上面的结果你会发现虽然是一个对象但是被设置进去两个值.
  32.     }
  34. }
  36. class Point {
  37.     int x;
  39.     public int getX() {
  40.         return x;
  41.     }
  43.     public void setX(int x) {
  44.         this.x = x;
  45.     }
  47.     @Override
  48.     public int hashCode() {
  49.         final int prime = 31;
  50.         int result = 1;
  51.         result = prime * result + x;
  52.         return result;
  53.     }
  55.     @Override
  56.     public boolean equals(Object obj) {
  57.         if (this == obj) return true;
  58.         if (obj == null) return false;
  59.         if (getClass() != obj.getClass()) return false;
  60.         Point other = (Point) obj;
  61.         if (x != other.x) return false;
  62.         return true;
  63.     }
  65.     @Override
  66.     public String toString() {
  67.         return "Point{" +
  68.                 "x=" + x +
  69.                 '}';
  70.     }
  71. }

演示内存泄漏案例2:

  1. import java.util.HashSet;
  3. /**
  4.  * 演示内存泄漏
  5.  */
  6. public class ChangeHashCode {
  7.     public static void main(String[] args) {
  8.         HashSet set = new HashSet();
  9.         Person p1 = new Person(1001, "AA");
  10.         Person p2 = new Person(1002, "BB");
  12.         set.add(p1);
  13.         set.add(p2);
  15.         p1.name = "CC";//导致了内存的泄漏
  16.         set.remove(p1); //删除失败
  18.         System.out.println(set);
  19.         //输出结果:[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
  20.     }
  21. }
  23. class Person {
  24.     int id;
  25.     String name;
  27.     public Person(int id, String name) {
  28.         this.id = id;
  29.         this.name = name;
  30.     }
  32.     @Override
  33.     public boolean equals(Object o) {
  34.         if (this == o) return true;
  35.         if (!(o instanceof Person)) return false;
  37.         Person person = (Person) o;
  39.         if (id != person.id) return false;
  40.         return name != null ? name.equals(person.name) : person.name == null;
  41.     }
  43.     @Override
  44.     public int hashCode() {
  45.         int result = id;
  46.         result = 31 * result + (name != null ? name.hashCode() : 0);
  47.         return result;
  48.     }
  50.     @Override
  51.     public String toString() {
  52.         return "Person{" +
  53.                 "id=" + id +
  54.                 ", name='" + name + '\'' +
  55.                 '}';
  56.     }
  57. }

控制台输出结果: 

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

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

  1. import java.util.HashSet;
  3. /**
  4.  * 演示内存泄漏
  5.  */
  6. public class ChangeHashCode {
  7.     public static void main(String[] args) {
  8.         HashSet set = new HashSet();
  9.         Person p1 = new Person(1001, "AA");
  10.         Person p2 = new Person(1002, "BB");
  12.         set.add(p1);
  13.         set.add(p2);
  15.        //  p1.name = "CC";//导致了内存的泄漏
  16.         set.remove(p1); //删除失败
  18.         System.out.println(set);
  19.         //输出结果:[Person{id=1002, name='BB'}]
  21.     }
  22. }
  24. class Person {
  25.     int id;
  26.     String name;
  28.     public Person(int id, String name) {
  29.         this.id = id;
  30.         this.name = name;
  31.     }
  33.     @Override
  34.     public boolean equals(Object o) {
  35.         if (this == o) return true;
  36.         if (!(o instanceof Person)) return false;
  38.         Person person = (Person) o;
  40.         if (id != person.id) return false;
  41.         return name != null ? name.equals(person.name) : person.name == null;
  42.     }
  44.     @Override
  45.     public int hashCode() {
  46.         int result = id;
  47.         result = 31 * result + (name != null ? name.hashCode() : 0);
  48.         return result;
  49.     }
  51.     @Override
  52.     public String toString() {
  53.         return "Person{" +
  54.                 "id=" + id +
  55.                 ", name='" + name + '\'' +
  56.                 '}';
  57.     }
  58. }

控制台输出结果是

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

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

  2. import java.util.HashSet;
  4. /**
  5.  * 演示内存泄漏
  6.  */
  7. public class ChangeHashCode {
  8.     public static void main(String[] args) {
  9.         HashSet set = new HashSet();
  10.         Person p1 = new Person(1001, "AA");
  11.         Person p2 = new Person(1002, "BB");
  13.         set.add(p1);
  14.         set.add(p2);
  17.         p1.name = "CC";//导致了内存的泄漏
  18.         set.remove(p1); //删除失败
  20.         System.out.println(set);
  21.         //输出结果:[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
  23.         set.add(new Person(1001, "CC"));
  24.         System.out.println(set);
  25.         //输出结果:[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}]
  27.         set.add(new Person(1001, "AA"));
  28.         System.out.println(set);
  29.         //输出结果: [Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}, Person{id=1001, name='AA'}]
  30.     }
  31. }
  33. class Person {
  34.     int id;
  35.     String name;
  37.     public Person(int id, String name) {
  38.         this.id = id;
  39.         this.name = name;
  40.     }
  42.     @Override
  43.     public boolean equals(Object o) {
  44.         if (this == o) return true;
  45.         if (!(o instanceof Person)) return false;
  47.         Person person = (Person) o;
  49.         if (id != person.id) return false;
  50.         return name != null ? name.equals(person.name) : person.name == null;
  51.     }
  53.     @Override
  54.     public int hashCode() {
  55.         int result = id;
  56.         result = 31 * result + (name != null ? name.hashCode() : 0);
  57.         return result;
  58.     }
  60.     @Override
  61.     public String toString() {
  62.         return "Person{" +
  63.                 "id=" + id +
  64.                 ", name='" + name + '\'' +
  65.                 '}';
  66.     }
  67. }

往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会自动丢弃这个值.

案例

  2. import java.util.HashMap;
  3. import java.util.Map;
  4. import java.util.WeakHashMap;
  5. import java.util.concurrent.TimeUnit;
  7. /**
  8.  * 演示内存泄漏
  9.  */
  10. public class MapTest {
  11.     static Map wMap = new WeakHashMap();
  12.     static Map map = new HashMap();
  14.     public static void main(String[] args) {
  15.         init();
  16.         testWeakHashMap();
  17.         testHashMap();
  18.     }
  20.     public static void init() {
  21.         String ref1 = new String("obejct1");
  22.         String ref2 = new String("obejct2");
  23.         String ref3 = new String("obejct3");
  24.         String ref4 = new String("obejct4");
  25.         wMap.put(ref1, "cacheObject1");
  26.         wMap.put(ref2, "cacheObject2");
  27.         map.put(ref3, "cacheObject3");
  28.         map.put(ref4, "cacheObject4");
  29.         System.out.println("String引用ref1，ref2，ref3，ref4 消失");
  31.     }
  33.     public static void testWeakHashMap() {
  35.         System.out.println("WeakHashMap GC之前");
  36.         for (Object o : wMap.entrySet()) {
  37.             System.out.println(o);
  38.         }
  39.         try {
  40.             System.gc();
  41.             TimeUnit.SECONDS.sleep(5);
  42.         } catch (InterruptedException e) {
  43.             e.printStackTrace();
  44.         }
  45.         System.out.println("WeakHashMap GC之后");
  46.         for (Object o : wMap.entrySet()) {
  47.             System.out.println(o);
  48.         }
  49.     }
  51.     public static void testHashMap() {
  52.         System.out.println("HashMap GC之前");
  53.         for (Object o : map.entrySet()) {
  54.             System.out.println(o);
  55.         }
  56.         try {
  57.             System.gc();
  58.             TimeUnit.SECONDS.sleep(5);
  59.         } catch (InterruptedException e) {
  60.             e.printStackTrace();
  61.         }
  62.         System.out.println("HashMap GC之后");
  63.         for (Object o : map.entrySet()) {
  64.             System.out.println(o);
  65.         }
  66.     }
  68. }

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

  1. String引用ref1，ref2，ref3，ref4 消失
  2. WeakHashMap GC之前
  3. obejct2=cacheObject2
  4. obejct1=cacheObject1
  5. WeakHashMap GC之后
  6. HashMap GC之前
  7. obejct4=cacheObject4
  8. obejct3=cacheObject3
  9. HashMap GC之后
  10. obejct4=cacheObject4
  11. obejct3=cacheObject3

监听器和回调

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