Java内部类导致内存泄露

约定不等于承诺〃 2023-10-13 20:43 43阅读 0赞

本文介绍 Java 内部类持有外部类导致内存泄露的原因以及其解决方案。今天给大家分享一种，Java内部类使用不当导致的内存泄露问题，最终导致内存溢出！希望能够帮助到大家！

## 1 为什么内部类持有外部类会导致内存泄露？ ##

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

### 1.1 解决方案 ###

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

## 2 为什么要持有外部类？ ##

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

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

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

报错：  
![在这里插入图片描述][72a96838d30345ca96b4b8c00db2e94f.png]

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

### 3.1 代码 ###

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

### 3.2 断点调试 ###

可以看到：内部类持有外部类的对象的引用，是以“this$0”这个字段来保存的。  
![在这里插入图片描述][4e07cba07d864f6396fc814b0df345b3.jpeg]

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

### 4.1 代码 ###

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

### 4.2 断点调试 ###

可以发现：内部类不再持有外部类了。  
![在这里插入图片描述][2d4eefd336bc47b2b8694f8249b1775a.jpeg]

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

### 5.1 简介 ###

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

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

### 5.2 代码 ###

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

### 5.3 测试 ###

可以看到：运行了八千多次的时候就内存溢出了。  
![在这里插入图片描述][466c0746e87d4a87be28429e434bddd4.jpeg]  
我换了一台 mac 电脑，4000 多就内存溢出了。

![在这里插入图片描述][cfb2c268bb9647458ec03df690e31974.jpeg]

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

### 6.1 简介 ###

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

### 6.2 代码 ###

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

### 6.3 测试 ###

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

![在这里插入图片描述][997a2fe2822d41f68c095010521c497a.jpeg]

[72a96838d30345ca96b4b8c00db2e94f.png]: https://img-blog.csdnimg.cn/72a96838d30345ca96b4b8c00db2e94f.png
[4e07cba07d864f6396fc814b0df345b3.jpeg]: https://img-blog.csdnimg.cn/4e07cba07d864f6396fc814b0df345b3.jpeg
[2d4eefd336bc47b2b8694f8249b1775a.jpeg]: https://img-blog.csdnimg.cn/2d4eefd336bc47b2b8694f8249b1775a.jpeg
[466c0746e87d4a87be28429e434bddd4.jpeg]: https://img-blog.csdnimg.cn/466c0746e87d4a87be28429e434bddd4.jpeg
[cfb2c268bb9647458ec03df690e31974.jpeg]: https://img-blog.csdnimg.cn/cfb2c268bb9647458ec03df690e31974.jpeg
[997a2fe2822d41f68c095010521c497a.jpeg]: https://img-blog.csdnimg.cn/997a2fe2822d41f68c095010521c497a.jpeg