漫谈GC——小心递归中产生的内存溢出

之前的文章中有系统的讲过GC相关的理论知识,如果对GC相关的理论知识不太理解的朋友,可以阅读一下:漫谈GC —— GC基本理论和深度剖析

提到递归,很多人的第一反应就是著名的 StackOverflowException, 栈溢出错误, 能够理解递归调用的逻辑是操作系统上的一个压栈操作,通常情况下,栈的内存非常小,所以调用层次很深的话就会产生类似的错误。我做了一个小测试,看一下调用多少层之后,我的系统会报出栈溢出。

代码如下(C#实现):

public class TestClass
    {
        public void M1(int num)
        {
            if (num < int.MaxValue)
            {
                num++;
                Console.WriteLine(num);
                M1(num);
            }
        }
    }

可以看到我设置的递归出口是int自增到int最大值的时候退出。

栈溢出统计

可以看到我的机器大概会在51520次的时候,栈溢出。由于方法里面几乎没有额外操作,所以这个数值比实际情况中大一些,而且计算机不同,结果肯定也不一样,日常的方法调用层数一般不会大于这个数值,所以常规的开发中,栈溢出基本上不会碰到。这里不是为了测试栈溢出的临界值的,所以只是简单理解一下栈溢出的异常就够了。

那这里提出一个问题,递归有没有可能内存溢出呢?

看下面这段测试代码(C#):

       public void M1(int num)
        {
            Console.WriteLine("倒数第:" + num); //输出
            int[] arr = new int[100000]; //定义了一个长度为10W的数组
            for (int i = 0; i < arr.Length; i++)
            {
                arr[i] = 100;
            }
            if (num > 0)
            {
                M1(num - 1);
            }
        }
       public static void Main(string[] args)
        {
            temp.M1(50000);//由于我的电脑的栈溢出大概在50000以上,所以设置50000,看一下效果
        }

上面的代码也不难理解,有几点提及一下:

  • 我的电脑 的栈溢出在50000+,所以调用层数设置为50000,
  • 每次递归的时候,定义了一个比较大的数组,长度为10W,每次赋值之后没有额外的任何操作。

我们看一下执行的结果:

内存溢出

可以看到,发生了OutOfMemoryException内存溢出,而递归只进行了不到10000次。

C# & Java GC算法


这里不谈太多的理论上的内容,理论上的细节可以看我在开篇引言中提到的另一篇文章。
C#与Java中,GC采用的是GC Root 的链路可达性分析算法解决的GC标记问题。原理就是一个对象只要有GC Root引用,就不会释放,这个不难理解,那么什么对象会被定义为GC Root对象呢?
GC Root对象大概包括这几类(我在概念文章里也提及了):

  • 虚拟机栈对象(JVM,CLR等)
  • OS 栈(操作系统本地方法的栈,Native)
  • 方法区中的常量或者静态引用的对象等。

上面的例子就是由于方法压栈,产生的问题,每一个新生成的数组,都被压栈进去的方法所引用,进行GC的时候,都是可达对象,无法GC,所以不会被释放。

实际生产问题


这里描述一下当时的问题:
当时是有一个服务器的文件夹,里面存储了大量的mp3文件,递归的过程中,需要把他们统一取出来,放入一个数组,过程中使用了递归的方式遍历所有文件夹下的文件,生成了大量的临时字符串,而字符串本质上也是一个byte数组,长度很大的话,也是比较消耗内存的,递归过程中同样不被释放,而服务器的内存较小,只有2GB。本地测试的时候,机器是16G电脑,没有问题,但是到服务器上就崩溃了。


递归虽然是很优雅的编程方式,在诸多算法里面也是热点,但是同样不能忽视递归调用过程中的栈溢出,以及上文提及的内存溢出

后记

Go语言的垃圾回收机制,没有使用链路可达性分析,而是三色标记法,细节可以看这里

这里还是贴一段代码:

package main

var count = 0
func main() {
    arr := make([]int,10)
    test(arr)
}

func test(arr []int ) []int {
    if count == 20 {
            return arr
        }else{
            count++
            caps:= cap(arr)
        for i:= 0;i< 2 * caps;i++{
            arr = append(arr, i)
        }
        println(arr, cap(arr))
        arr = test(arr)
    }
    return arr
}

上面的递归算法同样没有到20次,就抛出了内存溢出,请了解Go的小伙伴通过对三色标记法的理解,留言讨论一下吧。

你可能感兴趣的:(漫谈GC——小心递归中产生的内存溢出)