如何避免堆栈溢出？

Question

我使用 CSharpCodeProvider 编译代码，并在结果程序集中动态创建某个类的实例。比我调用一些方法。如果该方法有递归，我会得到 StackOverflowException 并且我的应用程序终止。

我该如何避免这种情况？

using System;
using System.Runtime.Remoting;
namespace TestStackOverflow
{
    class Program
    {
        class StackOver : MarshalByRefObject
        {
            public void Run()
            {
                Run();
            }
        }

        static void Main(string[] args)
        {
        AppDomain domain = AppDomain.CreateDomain("new");

        ObjectHandle handle = domain.CreateInstance(typeof (StackOver).Assembly.FullName, typeof (StackOver).FullName);
        if (handle != null)
        {
            StackOver stack = (StackOver) handle.Unwrap();
            stack.Run();
        }

    }
}
}

有关的：

什么是堆栈溢出？

Answer 1

StackOverflow 表明您的递归太深并且堆栈内存不足。例如：

public class StackOver
{
    public void Run() 
    { 
        Run(); 
    }
}

这将导致堆栈溢出，因为 StackOver::Run() 将被一遍又一遍地调用，直到没有剩余内存为止。

我怀疑在你的情况下，你可能缺少终止条件或者你运行了太多的递归迭代。

如果您尝试保持应用程序运行，请尝试：

namespace TestStackOverflow
{
    class Program
    {
        class StackOver : MarshalByRefObject
        {
            public bool Run()
            {
                return true; // Keep the application running. (Return false to quit)
            }
        }

        static void Main(string[] args)
        {
            // Other code...

            while (stack.Run());
        }

    }
}

Answer 2

Run正在调用Run。这就是无限递归。

    class StackOver : MarshalByRefObject
    {
        public void Run()
        {
            Run(); // Recursive call with no termination
        }
    }

Answer 3

如果递归导致堆栈溢出，那么问题与编译类无关——递归函数需要终止条件，因为 C#（通常）不会优化尾部调用。

Answer 4

避免递归函数堆栈溢出的唯一方法是有一个明确的退出条件，无论输入如何，最终都会满足该条件。您可以定义最大深度并在达到该深度后停止进行递归调用，或者确保您检查的数据是有限的（并且在合理的限制内），或者两者的组合。

Answer 5

每次从方法 bar 调用方法 foo 时，bar 都会添加到调用堆栈中。调用堆栈用于跟踪调用方法之前代码所在的位置，以便在 foo 完成时可以返回那里。

以下递归函数

int Factorial(int n) {
    if (n == 0) { return 1; }
    return n * Factorial(n - 1);
}

在多次递归调用 Factorial(5) 后，调用堆栈将如下所示：

Factorial(5) -> Factorial(4) -> Factorial(3) -> Factorial(2) -> Factorial(1)

此时 n 为 1，因此函数停止调用递归情况并返回 1。然后程序开始回溯调用堆栈，整个过程返回 120。

如果没有调用堆栈，程序在执行完方法后将不知道要返回到哪里。

现在假设基本情况不存在，它看起来像这样：

int Factorial(int n) {
    return n * Factorial(n - 1);
}

在调用 Factorial(5) 的几次递归之后，调用堆栈将如下所示：

Factorial(5) -> Factorial(4) -> Factorial(3) -> Factorial(2) -> Factorial(1) -> Factorial(0) -> Factorial(-1) -> Factorial(-2) -> Factorial(-3) -> Factorial(-4) -> Factorial(-5) -> Factorial(-6) -> Factorial(-7) -> Factorial(-8) -> Factorial(-9) -> Factorial(-10) -> Factorial(-11) -> Factorial(-12) -> Factorial(-13) -> Factorial(-14) -> Factorial(-15) etc…

因为代码没有停止调用自身的点，所以它会一直这样下去，调用堆栈会越来越大，占用越来越多的内存，直到超过分配的内存，并抛出 StackOverflow 异常。

有两种方法可以阻止这种情况发生，最好的方法取决于具体情况。

1 提供基本案例。确保最终达到某个条件，阻止函数调用自身。在阶乘的情况下，n == 1，但也可能是已经过去了一定的时间，已经递归了一定的次数，某些计算的某些结果在某些范围内，等等。只要在堆栈太大之前停止回收即可。

2 删除递归并重新编写它。任何递归算法都可以重写为非递归算法。它可能不那么干净和优雅，但它是可以做到的。在阶乘参数中，它可能类似于：

int Factorial(int n) {
    int result = 1;

    for (int i = 0; i < n; i += 1) {
        result *= n;
    }

    return result;
}

如果目标是一次又一次地不断运行相同的函数，那么您可以将递归重写

void Foo() {
    // Some code
    Foo();
}

为

void Foo() {
    while (true) { // Some code }
}

Answer 6

我没有很好的 CSharpCodeProvider 背景，但我知道递归实现的算法可以用循环来实现

Answer 7

好的。使用或不使用 CSharpCodeProvider 并不重要。我正在另一个域中使用反射加载程序集。我认为域是出于安全原因而创建的。我怎样才能防止应用程序终止？？？

using System;
using System.Runtime.Remoting;
namespace TestStackOverflow
{
    class Program
    {
        class StackOver : MarshalByRefObject
        {
            public void Run()
            {
                Run();
            }
        }

        static void Main(string[] args)
        {
        AppDomain domain = AppDomain.CreateDomain("new");

        ObjectHandle handle = domain.CreateInstance(typeof (StackOver).Assembly.FullName, typeof (StackOver).FullName);
        if (handle != null)
        {
            StackOver stack = (StackOver) handle.Unwrap();
            stack.Run();
        }

    }
}
}