Java 内部类持有外部类导致内存泄露

蔚落 2023-10-14 17:53 41阅读 0赞

本文介绍 Java 内部类持有外部类导致内存泄露的原因以及其解决方案。

**为什么内部类持有外部类会导致内存泄露**

非静态内部类会持有外部类，如果有地方引用了这个非静态内部类，会导致外部类也被引用，垃圾回收时无法回收这个外部类（即使外部类已经没有其他地方在使用了）。

**解决方案**

*  不要让其他的地方持有这个非静态内部类的引用，直接在这个非静态内部类执行业务。
 *  将非静态内部类改为静态内部类。内部类改为静态的之后，它所引用的对象或属性也必须是静态的，所以静态内部类无法获得外部对象的引用，只能从 JVM 的 Method Area（方法区）获取到static类型的引用。

###  ###

### **为什么要持有外部类** ###

Java 语言中，非静态内部类的主要作用有两个：

*  当内部类只在外部类中使用时，匿名内部类可以让外部不知道它的存在，从而减少了代码的维护工作。
 *  当内部类持有外部类时，它就可以直接使用外部类中的变量了，这样可以很方便的完成调用，如下代码所示：

package org.example.a;
    class Outer{
           private String outerName = "Tony";
        class Inner{
               private String name;
            public Inner() {
                   this.name = outerName;        }    }
        Inner createInner() {
               return new Inner();    }}
    public class Demo {
           public static void main(String[] args) {
               Outer.Inner inner = new Outer().createInner();        System.out.println(inner);    }}

但是，静态内部类就无法持有外部类和其非静态字段了。比如下边这样就会报错：

package org.example.a;
    class Outer{
           private String outerName = "Tony";
        static class Inner{
               private String name;
            public Inner() {
                   this.name = outerName;        }    }
        Inner createInner() {
               return new Inner();    }}
    public class Demo {
           public static void main(String[] args) {
               Outer.Inner inner = new Outer().createInner();        System.out.println(inner);    }}

报错：

![图片][9a0ab283e93880bd7bde86b7d24c6db9.jpeg]

###  ###

### **实例：持有外部类** ###

**代码**

package org.example.a;
    class Outer{
           class Inner {
       
        }
        Inner createInner() {
               return new Inner();    }}
    public class Demo {
           public static void main(String[] args) {
               Outer.Inner inner = new Outer().createInner();        System.out.println(inner);    }}

**断点调试**

可以看到：内部类持有外部类的对象的引用，是以“this$0”这个字段来保存的。

![图片][5f9950ecfddc57f93fe0fe39d43c3657.jpeg]

###  ###

### **实例：不持有外部类** ###

**代码**

package org.example.a;
    class Outer{
           static class Inner {
       
        }
        Inner createInner() {
               return new Inner();    }}
    public class Demo {
           public static void main(String[] args) {
               Outer.Inner inner = new Outer().createInner();        System.out.println(inner);    }}

**断点调试**

可以发现：内部类不再持有外部类了。

![图片][faa51541b677cde2d023a476dcec621b.jpeg]

###  ###

### **实例：内存泄露** ###

**简介**

若内部类持有外部类的引用，对内部类的使用很多时，会导致外部类数目很多。此时，就算是外部类的数据没有被用到，外部类的数据所占空间也不会被释放。

本处在外部类存放大量的数据来模拟。

**代码**

package org.example.a;
    import java.util.ArrayList;import java.util.List;
    class Outer{
           private int[] data;
        public Outer(int size) {
               this.data = new int[size];    }
        class Innner{
       
        }
        Innner createInner() {
               return new Innner();    }}
    public class Demo {
           public static void main(String[] args) {
               List<Object> list = new ArrayList<>();        int counter = 0;        while (true) {
                   list.add(new Outer(100000).createInner());            System.out.println(counter++);        }    }}

**测试**

可以看到：运行了八千多次的时候就内存溢出了。

![图片][c92f85fb4a68eca9068cbc03f73789aa.jpeg]

我换了一台 mac 电脑，4000 多就内存溢出了。

![图片][a747135cf4094895c30bffa552852c0b.jpeg]

###  ###

### **不会内存泄露的方案** ###

**简介**

内部类改为静态的之后，它所引用的对象或属性也必须是静态的，所以静态内部类无法获得外部对象的引用，只能从 JVM 的 Method Area（方法区）获取到 static 类型的引用。

**代码**

package org.example.a;
    import java.util.ArrayList;import java.util.List;
    class Outer{
           private int[] data;
        public Outer(int size) {
               this.data = new int[size];    }
        static class Inner {
       
        }
        Inner createInner() {
               return new Inner();    }}
    public class Demo {
           public static void main(String[] args) {
               List<Object> list = new ArrayList<>();        int counter = 0;        while (true) {
                   list.add(new Outer(100000).createInner());            System.out.println(counter++);        }    }}

**测试**

可以发现：循环了四十多万次都没有内存溢出。

![图片][4aac6753d14a9b3afe73f6655ecdf563.jpeg]

[9a0ab283e93880bd7bde86b7d24c6db9.jpeg]: https://img-blog.csdnimg.cn/img_convert/9a0ab283e93880bd7bde86b7d24c6db9.jpeg
[5f9950ecfddc57f93fe0fe39d43c3657.jpeg]: https://img-blog.csdnimg.cn/img_convert/5f9950ecfddc57f93fe0fe39d43c3657.jpeg
[faa51541b677cde2d023a476dcec621b.jpeg]: https://img-blog.csdnimg.cn/img_convert/faa51541b677cde2d023a476dcec621b.jpeg
[c92f85fb4a68eca9068cbc03f73789aa.jpeg]: https://img-blog.csdnimg.cn/img_convert/c92f85fb4a68eca9068cbc03f73789aa.jpeg
[a747135cf4094895c30bffa552852c0b.jpeg]: https://img-blog.csdnimg.cn/img_convert/a747135cf4094895c30bffa552852c0b.jpeg
[4aac6753d14a9b3afe73f6655ecdf563.jpeg]: https://img-blog.csdnimg.cn/img_convert/4aac6753d14a9b3afe73f6655ecdf563.jpeg