为什么Java递归调用不会释放局部变量内存

Question

I have a recursion method like below

private void foo(int i){
    byte[] a = new byte[1 * 1024 * 1024];
    System.out.println(i+" "+a.length);
    foo(i+1);
}

I find the local variable a cannot be released and if I set the maximum heap size 50M (-Xmx50M) it will meet OOM at the 44th call

44 1048576
java.lang.OutOfMemoryError: Java heap space

but changed it to for loop it does not have this problem

private void bar(){
    int index = 1;
    while (true) {
        byte[] a = new byte[1 * 1024 * 1024];
        System.out.println(index+" "+a.length);
        index += 1;
    }
}

So why in recursion call it not release the memory of local variable?

Answer 1

在方法返回后（即执行第一个foo之后）会发生释放，但是在您的情况下，它将调用另一个foo ，后者也会创建一个新的字节数组，并调用第三个foo ，因此它会累加所有字节数组，并且垃圾收集器不会尝试清除它们，直到它们全部返回，或者您获得OOM。

Answer 2

Java does not deallocate local variables from the stack until the method returns. So even though the local variable will never be used, it is still referenced, and therefore the array cannot be garbage-collected until the method returns.

Also Java does not implement tail call optimisation at all, so there is no early return involved.

Answer 3

In for loop variable a is bound to scope of the for loop so reference to array is released after every iteration and garbage collector can deallocate that memory.

When you do recurssion references of every array is stored on stack so garbage collector can't destroy those arrays since someone(in this case stack) is referencing those arrays. Imagine this situation:

private void foo(int i){
    byte[] a = new byte[1 * 1024 * 1024];
    System.out.println(i+" "+a.length);
    foo(i+1);
    a[1] += a[0] + 1;
}

This function demonstrates that even after the recursive call array a could still be used.

BONUS: The type of recursion you presented is called tail recursion and there are algorithms that can automatically convert those to loops so in languages like Kotlin you could do this:

tailrec fun foo(i: Int): Boolean {
    var a = Array<Byte>(1 * 1024 * 1024, { 0 });
    System.out.println("$i ${a.size}");
    foo(i + 1);
}

This would work because Kotlin compiler would turn this into a for or while loop.

Answer 4

递归在这种情况下不起作用，因为Java必须将方法的每个实例都存储在内存中，因此当您递归调用它时，它将用完ram，但是当您使用循环时，它可以使用无法使用的优化递归。