标签: stack-overflow

我一直在比较有趣的不同语言的速度执行以下程序:对于i从1到1000000总和产品i*(sqrt i)

我的一个实现(不是唯一的)是构造一个列表[1..1000000],然后用特定的函数折叠.

该程序在Haskell中工作得很好(即使使用foldl而不是foldl'),但在OCaml和F#中堆栈溢出.

这是Haskell代码:

test = foldl (\ a b -> a + b * (sqrt b)) 0

create 0 = []
create n = n:(create (n-1))

main = print (test (create 1000000))

这是OCaml:

let test = List.fold_left (fun a b -> a +. (float_of_int b) *. (sqrt (float_of_int b))) 0. ;;

let rec create = function
    | 0 -> []
    | n -> n::(create (n-1)) ;;

print_float (test (create 1000000));;

为什么OCaml/F#实现堆栈溢出？

可能重复:
什么是堆栈溢出错误？

任何人都可以告诉我如何以及为什么在程序中实际发生堆溢出和堆溢出,以及如何克服编程中的堆栈溢出 - 如何避免它？

我在Server 2008 R2 + IIS 7.5上运行的ASP.NET应用程序中有一些代码.每当我加载一个特定的页面时,它将永远挂起并将IIS发送到100%的CPU使用率.我最终追查了这个问题.

public string Comments
{
    get { return this.Comments; }
}

哎呀 - 本来应该的return this.Photo.Comments.所以,我的问题是,为什么.NET没有生成StackOverflowException,而是让IIS以100%的CPU运行的时间远远超过应该的时间.根据我使用.NET编程的经验,在执行上述操作时,需要几秒或更短时间才能获得StackOverflowException.那么它怎么能在IIS上运行近30分钟呢？

经过一些演示,我遇到了以下声明:当JVM加载一个类时,它可以分析其内容并确保操作数堆栈没有溢出或下溢.我发现很多来源都提出了相同的主张,但没有说明它是如何完成的.

我不清楚如何使用静态分析进行此类验证.假设我有一个(恶意)方法,它可以获得一些值作为参数,并使用它来执行一系列弹出.在加载时,迭代次数是未知的,因为它取决于方法调用者给出的参数.因此,在我看来,只有在运行时才能确定是否会出现下溢.我在这里错过了什么？

我是java的新手.我在regex strHindiText中得到java Stack overflow Exception.我该怎么办？

try {
     // This regex convert the pattern "{\fldrslt {\fcs1 \ab\af24 \fcs0 ऩ}{"
     // into "{\fldrslt {\fcs1 \ab\af24 \fcs0 ऩ}}}{"
     // strHindiText = strHindiText.replaceAll("\\{(\\\\fldrslt[ ])\\{((\\\\\\S+[ ])+)((\\s*&#\\d+;\\s*(-|,|/|\\(|\\)|\"|;|\\.|'|<|>|:|\\?)*)+)\\}\\{","{$1{$2$4}}}{");

     // This regex convert the pattern "{\fcs0 \af0 &#2345;{ or {\fcs0 \af0 *\tab &#2345;{" 
     // into "{\fcs0 \af0 &#2345; }{"
     strHindiText = strHindiText.replaceAll("\\{\\s*((\\\\\\S+[ ](\\*)?)+\\s*)(-|,|/|\\(|\\)|\"|;|\\.|'|<|>|:|\\?)*[ ]*(((&#\\d+;)[ ]*(-|,|/|\\(|\\)|\"|;|\\.|'|<|>|:|\\?)*[ ]*)+)\\{", "{$1 $4$5 }{");

     // This regex convert the pattern "{&#2345; \fcs0 \af0 {" 
     // into "{&#2345; \fcs0 \af0 }{"
     strHindiText = strHindiText.replaceAll("\\{\\s*(((&#\\d+;)[ …

我们有很多嵌套的异步方法,看到我们并不真正理解的行为.以这个简单的C#控制台应用程序为例

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace AsyncStackSample
{
  class Program
  {
    static void Main(string[] args)
    {
      try
      {
        var x = Test(index: 0, max: int.Parse(args[0]), throwException: bool.Parse(args[1])).GetAwaiter().GetResult();
        Console.WriteLine(x);
      }
      catch(Exception ex)
      {
        Console.WriteLine(ex);
      }
      Console.ReadKey();
    }

    static async Task<string> Test(int index, int max, bool throwException)
    {
      await Task.Yield();

      if(index < max)
      {
        var nextIndex = index + 1;
        try
        {
          Console.WriteLine($"b {nextIndex} of {max} (on threadId: {Thread.CurrentThread.ManagedThreadId})");

          return await Test(nextIndex, …

这很容易解释:这很有效

using System;
using ConstraintSet = System.Collections.Generic.Dictionary<System.String, double>;

namespace ConsoleApplication2
{
    class test
    {
        public ConstraintSet a { get; set; }
        public test()
        {
            a = new ConstraintSet();
        }
        static void Main(string[] args)
        {
            test abc = new test();
            Console.WriteLine("done");
        }
    }
}

这不

using System;
using ConstraintSet = System.Collections.Generic.Dictionary<System.String, double>;

namespace ConsoleApplication2
{
    class test
    {
        public ConstraintSet a { get { return a; } set { a = value; } }
        public test()
        {
            a = new ConstraintSet(); …

在C中捕获堆栈溢出的最佳方法是什么？

进一步来说:

AC程序包含脚本语言的解释器.

脚本不受信任,可能包含无限的递归错误.口译员必须能够抓住这些并顺利地继续下去.(显然,这可以通过使用软件堆栈来部分处理,但是如果可以用C语言编写大量的库代码块,性能会大大提高;至少,这需要在脚本创建的递归数据结构上运行C函数.)

捕获堆栈溢出的首选形式将涉及longjmp返回主循环.(丢弃在主循环下面的堆栈帧中保存的所有数据是完全可以的.)

回退可移植解决方案是使用局部变量的地址来监视当前堆栈深度,并使用每个递归函数来包含对使用此方法的堆栈检查函数的调用.当然,这会在正常情况下产生一些运行时开销; 这也意味着如果我忘记将堆栈检查调用放在一个地方,解释器将有一个潜在的错误.

有没有更好的方法呢？具体来说,我不期待更好的可移植解决方案,但如果我有一个针对Linux的系统特定解决方案和另一个适用于Windows的解决方案,那就没关系.

我见过在Windows上引用了一些称为结构化异常处理的东西,尽管我看过的引用一直是将它转换为C++异常处理机制; 可以从C访问它,如果是这样,它对这种情况有用吗？

我了解Linux可以捕获分段故障信号; 是否可以将其可靠地转换为longjmp回到主循环？

Java似乎支持在所有平台上捕获堆栈溢出异常; 它是如何实现的？

我正在尝试编写一个Java程序来计算大数的阶乘.似乎BigInteger无法容纳这么大的数字.

以下是我写的(直截了当的)代码.

 public static BigInteger getFactorial(BigInteger num) {
      if (num.intValue() == 0) return BigInteger.valueOf(1);

      if (num.intValue() == 1) return BigInteger.valueOf(1);

      return num.multiply(getFactorial(num.subtract(BigInteger.valueOf(1))));
  }

上述程序在5022中处理的最大数量,之后程序抛出一个StackOverflowError.有没有其他方法来处理它？

我一直在努力在Native Android App哪里面对一些特殊的错误Android 2.3.3 versions and below Android 3.0 version.

我没有得到我的代码究竟在哪里,因为在Logcat编译的每一行代码,但最后我得到了非常奇怪的错误描述日志如下:

java.lang.StackOverflowError
at java.util.concurrent.locks.ReentrantLock$NonfairSync.tryAcquire(ReentrantLock.java:189)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1171)
at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:185)
at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:261)
at java.util.concurrent.CopyOnWriteArrayList.removeRange(CopyOnWriteArrayList.java:569)
at java.util.concurrent.CopyOnWriteArrayList.remove(CopyOnWriteArrayList.java:366)
at java.util.concurrent.CopyOnWriteArrayList.remove(CopyOnWriteArrayList.java:376)
at android.view.ViewTreeObserver.removeOnPreDrawListener(ViewTreeObserver.java:377)

at android.widget.TextView.onDraw(TextView.java:4085)
at android.view.View.draw(View.java:6986)
at android.view.ViewGroup.drawChild(ViewGroup.java:1739)
at android.view.ViewGroup.dispatchDraw(ViewGroup.java:1466)
at android.view.ViewGroup.drawChild(ViewGroup.java:1737)
at android.view.ViewGroup.dispatchDraw(ViewGroup.java:1466)
at android.view.ViewGroup.drawChild(ViewGroup.java:1737)
at android.view.ViewGroup.dispatchDraw(ViewGroup.java:1466)
at android.view.View.draw(View.java:6989)
at android.view.ViewGroup.drawChild(ViewGroup.java:1739)
at android.view.ViewGroup.dispatchDraw(ViewGroup.java:1466)
at android.view.View.draw(View.java:6989)
at android.view.ViewGroup.drawChild(ViewGroup.java:1739)
at android.view.ViewGroup.dispatchDraw(ViewGroup.java:1466)
at android.view.ViewGroup.drawChild(ViewGroup.java:1737)

    at android.view.ViewGroup.dispatchDraw(ViewGroup.java:1466)
at android.view.ViewGroup.drawChild(ViewGroup.java:1737)
at android.view.ViewGroup.dispatchDraw(ViewGroup.java:1466)
at android.view.View.draw(View.java:6989)
at android.view.ViewGroup.drawChild(ViewGroup.java:1739)
at android.view.ViewGroup.dispatchDraw(ViewGroup.java:1466)
at android.view.View.draw(View.java:6989)
at android.view.ViewGroup.drawChild(ViewGroup.java:1739)
at android.view.ViewGroup.dispatchDraw(ViewGroup.java:1466) …