JVM--Java内存泄露--内部类持有外部类--原因/解决方案

Myth丶恋晨 2023-01-16 06:45 131阅读 0赞

原文网址：[JVM--Java内存泄露--内部类持有外部类--原因/解决方案][JVM--Java_--_--]

# 简介 #

说明

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

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

非静态内部类会持有外部类，如果有地方引用了这个非静态内部类，会导致外部类也被引用，垃圾回收时无法回收这个外部类。

**解决方案**

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

# 普通内部类 #

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

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

报错：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70][]

## 复现持有外部类 ##

**代码**

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”这个字段来保存的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 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);
        }
    }

**断点调试**

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

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

**测试**

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 3][]

## 复现不会内存泄露 ##

**简介**

内部类改为静态的之后，它所引用的对象或属性也必须是静态的，所以静态内部类无法获得外部对象的引用，只能从 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++);
            }
        }
    }

**测试**

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 4][]

# 匿名内部类 #

**其他网址**

[永远不要使用双花括号初始化实例，除非你想OOM！][OOM]

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

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

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

package org.example.a;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class Demo {
        private static String name = "Tony";
        public static void main(String[] args) {
            List<String> list = new ArrayList<String>() {
       {
                add("a");
                add("b");
                add(name);
            }};
            System.out.println(list);
        }
    }

## 复现持有外部类 ##

**代码**

package org.example.a;
    
    import java.util.ArrayList;
    import java.util.List;
    
    class Test{
        public List<String> createList() {
            List<String> list = new ArrayList<String>() {
       {
                add("a");
                add("b");
            }};
            return list;
        }
    }
    
    public class Demo {
        public static void main(String[] args) {
            System.out.println(new Test().createList());
        }
    }

### **编译查看class** ###

命令：javac Demo.java

结果：

![2021042421440360.png][]

**Idea查看Test$1.class（可以发现：持有了一个外部类Test对象）**

package org.example.a;
    
    import java.util.ArrayList;
    
    class Test$1 extends ArrayList<String> {
        Test$1(Test var1) {
            this.this$0 = var1;
            this.add("a");
            this.add("b");
        }
    }

**Idea查看Test.class**

package org.example.a;
    
    import java.util.ArrayList;
    import java.util.List;
    
    class Test {
        Test() {
        }
    
        public List<String> createList() {
            ArrayList var1 = new ArrayList<String>() {
                {
                    this.add("a");
                    this.add("b");
                }
            };
            return var1;
        }
    }

**Idea查看Demo.class**

package org.example.a;
    
    public class Demo {
        public Demo() {
        }
    
        public static void main(String[] var0) {
            System.out.println((new Test()).createList());
        }
    }

### 查看字节码 ###

**命令**

javap -c Test$1.class

**结果**

Compiled from "Demo.java"
    class org.example.a.Test$1 extends java.util.ArrayList<java.lang.String> {
      final org.example.a.Test this$0;
    
      org.example.a.Test$1(org.example.a.Test);
        Code:
           0: aload_0
           1: aload_1
           2: putfield      #1                  // Field this$0:Lorg/example/a/Test;
           5: aload_0
           6: invokespecial #2                  // Method java/util/ArrayList."<init>":()V
           9: aload_0
          10: ldc           #3                  // String a
          12: invokevirtual #4                  // Method add:(Ljava/lang/Object;)Z
          15: pop
          16: aload_0
          17: ldc           #5                  // String b
          19: invokevirtual #4                  // Method add:(Ljava/lang/Object;)Z
          22: pop
          23: return
    }

**分析**

关键代码的在 putfield 这一行，此行表示有一个对 Test 的引用被存入到 this$0 中，也就是说这个匿名内部类持有了外部类的引用。

**代码验证**

package org.example.a;
    
    import java.lang.reflect.Field;
    import java.util.ArrayList;
    import java.util.List;
    
    class Test{
        public List<String> createList() {
            List<String> list = new ArrayList<String>() {
       {
                add("a");
                add("b");
            }};
            return list;
        }
    }
    
    public class Demo {
        public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
            List<String> list = new Test().createList();
            // 获取一个类的所有字段
            Field field = list.getClass().getDeclaredField("this$0");
            // 设置允许方法私有的 private 修饰的变量
            field.setAccessible(true);
            System.out.println(field.get(list).getClass());
        }
    }

打个断点（注意：我这里是用Object模式（右键Variables里的this=> View as=> Object））

可见：它是持有外部类Test的对象的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 5][]

执行结果：

class org.example.a.Test

## 什么时候会导致内存泄露 ##

非静态方法返回匿名内部类的引用可能导致内存泄露，例：

class Test{
        public List<String> createList() {
            List<String> list = new ArrayList<String>() {
       {
                add("a");
                add("b");
            }};
            return list;
        }
    }

跟上边“普通内部类” 一样，若Test类里边有比较大的对象，而这些大对象根本没被用到，则会内存泄露。

## 不会内存泄漏的方案 ##

**方案1：业务直接处理，不返回内部类对象引用**

class Test{
        public void createList() {
            List<String> list = new ArrayList<String>() {
       {
                add("a");
                add("b");
            }};
            System.out.println(list);
        }
    }

**方案2：匿名内部类改为静态的**

将匿名内部类改为静态的。此时，内部类不会持有外部类的对象的引用。

为什么这样就不会内存泄露了？

因为匿名内部类是静态的之后，它所引用的对象或属性也必须是静态的了，因此就可以直接从 JVM 的 Method Area（方法区）获取到引用而无需持久外部对象了。

**代码**

package org.example.a;
    
    import java.util.ArrayList;
    import java.util.List;
    
    class Test{
        public static List<String> createList() {
            List<String> list = new ArrayList<String>() {
       {
                add("a");
                add("b");
            }};
            return list;
        }
    }
    
    public class Demo {
        public static void main(String[] args) {
            System.out.println(Test.createList());
        }
    }

执行结果

[a, b]

**编译**

**命令：**javac Demo.java

**结果**

![20210425001707612.png][]

**Idea查看Test$1.class**

package org.example.a;
    
    import java.util.ArrayList;
    
    final class Test$1 extends ArrayList<String> {
        Test$1() {
            this.add("a");
            this.add("b");
        }
    }

# **其他网址** #

[Java内部类持有外部类的引用详细分析与解决方案\_leunging的博客-CSDN博客\_内部类持有外部类][Java_leunging_-CSDN]  
[Java防止非静态内部类内存泄漏][Java]

[JVM--Java_--_--]: https://knife.blog.csdn.net/article/details/116096099
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70]: /images/20221022/cb0c92d1a3c1412b829b62c61377c20f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 1]: /images/20221022/b26423285e38454e9c1feca98ef6e75b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 2]: /images/20221022/2a63d56710754d7999afd70162e9613e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 3]: /images/20221022/65297ac377254666bdc28e42b946b20f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 4]: /images/20221022/7b8352d0cebe4f45af0f0f56e0875fe4.png
[OOM]: https://juejin.cn/post/6844904165878005767
[2021042421440360.png]: /images/20221022/d506313c3eee4ad3be6a5e2170a13eaa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 5]: /images/20221022/014e9dfec5f14d0197e371d101f1b80d.png
[20210425001707612.png]: /images/20221022/34741ddc90fe4fbf82ee7101da3affd7.png
[Java_leunging_-CSDN]: https://blog.csdn.net/leunging/article/details/53080863
[Java]: https://majing.io/posts/10000048512995