༺歲月蹉跎༻

只要路是对的,就不怕路远!

0%

内存泄漏

1、内存泄漏的理解和分类

  • 内存泄漏:

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

    • 严格来说,只有对象不会再被程序用到了,但是GC又不能回收他们的情况,才叫内存泄漏。

    • 但实际情况很多时候一些不太好的实践(或疏忽)会导致对象的生命周期变得很长甚至导致OOM,也可以叫做宽泛意义上的“内存泄漏”

      • 对象X引用对象Y,X的生命周期比Y的生命周期长。那么当V生命周期结束的时候,X依然引用着Y,这时候,垃圾回收期是不会回收对象Y的。
      • 如果对象X还引用着生命周期比较短的A、B、C,对象A又引用着对象a、b、c,这样就可能造成大量无用的对象不能被回收,进而占据了内存资源,造成内存泄漏,直到内存溢出。
  • 泄漏的分类:

    • 经常发生:发生内存泄露的代码会被多次执行,每次执行,泄露一块内存。
    • 偶然发生:在某些特定情况下才会发生。
    • 一次性:发生内存泄露的方法只会执行一次。
    • 隐式泄漏:一直占着内存不释放,直到执行结束;严格的说这个不算内存泄漏,因为最终释放掉了,但是如果执行时间特别长,也可能会导致内存耗尽。

2、内存泄漏的八种情况

  • ①静态集合类

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

      1
      2
      3
      4
      5
      6
      7
      8
      public class MemoryLeak {
      static List list = new ArrayList();

      public void oomTest() {
      Object obj = new Object();
      list.add(obj);
      }
      }
  • ②单例模式

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

    • 内部类持有外部类,如果一个外部类的实例对象的方法返回了一个内部类的实例对象。这个内部类对象被长期引用了,即使那个外部类实例对象不再被使用,但由于内部类持有外部类的实例对象,这个外部类对象将不会被垃圾回收,这也会造成内存泄漏。
  • ④各种连接,如数据库连接、网络连接和IO连接等

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

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

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      public class MemoryLeak {
      public static void main(String[] args) {
      try {
      Connection conn;
      Class.forName("com.mysql.jdbc.Driver");
      Statement statement = conn.createStatement();
      ResultSet resultSet = statement.executeQuery("....");
      } catch (ClassNotFoundException | SQLException e) {
      e.printStackTrace();
      } finally {
      //1.关闭结果集 Statement
      //2.关闭声明的对象 Resultset
      //3.关闭连接Connection
      }
      }
      }
  • ⑤变量不合理的作用域

    • 一般而言,一个变量的定义的作用范围大于其使用范围,很有可能会造成内存泄漏。另一方面,如果没有及时地把对象设置为null,很有可能导致内存泄漏的发生。
  • ⑥改变哈希值

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

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

    • 例子1:

      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
      public class MemoryLeak {
      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 此行为导致了内存的泄漏

      System.out.println("hs.remove = " + hs.remove(cc));//false
      hs.add(cc);
      System.out.println("hs.size = " + hs.size());//size = 2

      System.out.println(hs);
      }
      }
      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
      hs.remove = false
      hs.size = 2
      [Point{x=20}, Point{x=20}]
    • 例子2:

      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
      public class MemoryLeak {
      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 + '\'' +
      '}';
      }
      }

      执行结果:

      1
      2
      3
      [Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
      [Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}]
      [Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}, Person{id=1001, name='AA'}]
  • ⑦缓存泄露

    • 内存泄漏的另一个常见来源是缓存,一旦你把对象引用放入到缓存中,他就很容易遗忘。比如:之前项目在一次上线的晴候,应用启动奇慢直到夯死,就是因为代码中会加载一个表中的数据到缓存(内存)中,测试环境只有几百条数据,但是生产环境有几百万的数据。

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

      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
      public class MemoryLeak {
      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
      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

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

  • ⑧监听器和回调

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