匿名内部类为什么泄漏，Lambda为什么不泄漏

news2024/7/6 19:26:05

作者：麦客奥德彪

在Android开发中，内存泄露发生的场景其实主要就两点，一是数据过大的问题，而是调用与被调用生命周期不一致问题，对于对象生命周期不一致导致的泄漏问题占90%，最常见的也不好分析的当属匿名内部类的内存泄漏。

最近在开发时遇到了一个问题，就是LeakCannry 检测到的内存泄漏，LeakCannry检测的原理大概就是GC 可达性算法实现的，我们产品中最多的一个问题就是匿名内部类导致的。

案例不涉及持有外部类引用的状态下

匿名内部类如何导致内存泄漏

在Java体系中，内部类有多种，最常见的就是静态内部类、匿名内部类，一般情况下，都推荐使用静态内部类，那这是为什么呢，先看一个例子：

public class Test {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {

            }
        }).start();
    }
}

匿名内部类的泄漏原因：内部类持有外部类的引用，上述场景中，当外部类销毁时，匿名内部类Runnable 会导致内存泄漏，

验证这个结论

上述代码的class 文件通过Javap -c 查看后是这样的

Compiled from "Test.java"
public class Test {
  public Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/Thread
       3: dup
       4: new           #3                  // class Test$1
       7: dup
       8: invokespecial #4                  // Method Test$1."<init>":()V
      11: invokespecial #5                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
      14: invokevirtual #6                  // Method java/lang/Thread.start:()V
      17: return
}

我们直接看main 方法中的指令：

0: new #2 // 创建一个新的 Thread 对象 
3: dup // 复制栈顶的对象引用 
4: new #3 // 创建一个匿名内部类 Test$1 的实例 
7: dup // 复制栈顶的对象引用 
8: invokespecial #4 // 调用匿名内部类 Test$1 的构造方法 
11: invokespecial #5 // 调用 Thread 类的构造方法，传入匿名内部类对象 
14: invokevirtual #6 // 调用 Thread 类的 start 方法，启动线程 
17: return // 返回

我们可以看到，在第4步中使用new 指令创建了一个Test$1的实例，并且在第8步中，通过invokespecial 指令调用匿名内部类的构造方法，这样一来生成的内部类就会持有外部类的引用，从而外部类不能回收，将导致内存泄漏。

Lambda为什么不泄漏

刚开始，我以为Lambda只是语法糖，不会有其他的作用，然而，哈哈大家估计已经想到了，

匿名内部类使用Lambda 时不会造成内存泄漏。

看代码：

public class Test {
    public static void main(String[] args) {
        new Thread(() -> {

        }).start();
    }
}

将上面的代码改为Lambda 格式

class 文件：

Compiled from "Test.java"
public class Test {
  public Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/Thread
       3: dup
       4: invokedynamic #3,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable;
       9: invokespecial #4                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
      12: invokevirtual #5                  // Method java/lang/Thread.start:()V
      15: return
}

第一眼看上去就已经知道了答案，在这份字节码中没有生成内部类，

在Lambda格式中，没有生成内部类，而是直接使用invokedynamic 指令动态调用run方法，生成一个Runnable对象。再调用调用Thread类的构造方法，将生成的Runnable对象传入。从而避免了持有外部类的引用，也就避免了内存泄漏的发生。

在开发中，了解字节码知识还是非常有必要的，在关键时刻，我们查看字节码，确实能帮助自己解答一些疑惑，下面是常见的一些字节码指令