相关疑难解决方法(0)

如果我在Java中递归调用一个方法，我可以提前知道在得到StackOverflowException之前有多少次调用会成功吗？即某种堆栈大小有望在 WAS 中配置？

我正在 ANTLR4 中重新实现现有的 DSL。现有的源代码主体有一些非常大的表达式。ALL(*) 逻辑中的递归似乎意味着我可以解析的表达式有多大限制。

示例语法：（刚好足以重现这里的错误错误）

  grammar A4Test;

  fragment DIGIT : [0-9];

  fragment ALPHA : [a-zA-Z];


  WS  :   [ \t\r\n\u000D'] {skip();};
    
  ID  :   ALPHA (ALPHA|DIGIT)*;
        
  NUMBER : '-'?(DIGIT+|(DIGIT*'.'DIGIT+));
     
  e : expr;
          
  expr : '(' expr ')'
    |   expr 'OR' expr
    |   expr 'AND' expr
    |   ID
    |   NUMBER
    ; 
 

样本输入：

V0 AND 0 OR
V1 AND 1 OR
...  (MANY rows elided)
V3999 AND 3999 OR
V4000 AND 4000

堆栈跟踪：

Exception in thread "main" java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) …

我正在尝试在 PC（或更准确地说，运行 Neo4j 2.1.0 的 MacBookPro 10.9.2）上创建一个相对较小的 Neo4j 数据库，由 1400 个 CREATE 语句组成。当我通过终端加载图形文件时，我收到以下错误消息（整个堆栈跟踪对于 Stackoverflow 来说太长，但这里是错误消息和引起原因列表的前三行）：

Error occurred in server thread; nested exception is:     
java.lang.StackOverflowError
java.rmi.ServerError: Error occurred in server thread; nested exception is:     
java.lang.StackOverflowError
at sun.rmi.server.UnicastServerRef.dispatch(UnicastServerRef.java:350)
at sun.rmi.transport.Transport$1.run(Transport.java:177)
at sun.rmi.transport.Transport$1.run(Transport.java:174)

...

Caused by: java.lang.StackOverflowError
at org.neo4j.cypher.internal.compiler.v2_1.ReattachAliasedExpressions$.apply(ReattachAliasedExpressions.scala:31)
at org.neo4j.cypher.internal.compiler.v2_1.ReattachAliasedExpressions$$anonfun$2.apply(ReattachAliasedExpressions.scala:36)
at org.neo4j.cypher.internal.compiler.v2_1.ReattachAliasedExpressions$$anonfun$2.apply(ReattachAliasedExpressions.scala:36)
at scala.Option.map(Option.scala:145)

我可以将所有 1400 个创建语句加载到包含 300 个创建语句的单独文件中，因此我的 Cypher 似乎是正确的。如何增加堆栈大小以便上传更大的 Neo4j 数据库？（我正在通过大量的 xml 创建数据库，并期望在最终分析中必须有大约 3000 个节点和大约 4000 个关系）。

我有一个常规的64位热点JVM,其堆栈大小为1 MB.现在我试图序列化一个具有3022个父级的层次结构的对象,这给了我SO(反讽)异常.

这是一些代码:

while(epc.getParent()!=null){

      epc=epc.getParent();
      count++;
     }
     print(count);//3022

上面的代码只是告诉层次结构,但当我尝试将epc对象序列化到ObjectOutputStream 时,会发生实际问题.

问题,JVM中1 MB堆栈大小的状态是什么,因为我不知道堆栈帧的大小是多少？我确定每个堆栈帧不是1KB,因为我在-Xss3000k成功运行了代码.

还有一个问题,如果我放置-Xss3000k的JVM选项,每个线程的堆栈大小是否为3000k？

这是我的代码,它运行良好,值为400到4000,但一旦它大约4mil,我得到堆栈溢出错误.

提前致谢!

public class Fib {
static int c=1,b=2;
static long sum1=0,sum2=0;

static long fib(long a){
if(a==1){
    return 1;
}
if(a==2){
    return 2;
}
else{
    return fib(a-1)+fib(a-2);
}

    }


    public static void main(String[] args){
sum2= fib(4000000);
    System.out.println("Sum %f" +sum2);
}
    }

我想做一个BigInteger的阶乘（在Kotlin中）。使用尾部递归时，当我尝试执行9000时会出现StackOverFlow错误！。使用非递归函数，我可以做到这一点……但是我很好奇如何避免这种错误。

这是我的代码：

import java.math.BigInteger

fun tail_recursion_factorial(n: BigInteger, factorialOfN: BigInteger = BigInteger.valueOf(2)): BigInteger {
   return when(n){
        BigInteger.ONE ->  BigInteger.ONE
        BigInteger.valueOf(2) ->  factorialOfN
        else -> tail_recursion_factorial(n.minus(BigInteger.ONE), n.times(factorialOfN))
    }
}
fun non_recursive_factorial(n: BigInteger): BigInteger{
    var i: BigInteger = BigInteger.ONE
    var factorial: BigInteger = BigInteger.ONE
    while (i<=n){
        factorial = factorial.times(i)
        i = i.plus(BigInteger.ONE)
    }
    return factorial
}
fun main(args: Array<String>){
    print("n == ")
    var n = readLine()!!
    //recursive
    //println("$n! is ${tail_recursion_factorial(BigInteger(n))}")
    //non-recursive
    println("$n! is ${non_recursive_factorial(BigInteger(n))}")
}

我应该比较一个递归函数和一个非递归函数,看看哪个类项目更快.当迭代器等于10,100,1000等时,教授还希望我们以毫秒为单位计算迭代次数.我得到了所有工作,但是在C++中获得计时器时遇到了很多麻烦,所以我切换到了Java,因为它太多了更容易获得毫秒输出.

但是现在当我尝试使用超过8,000的任何数字时,我从递归算法中得到了一个很大的堆栈溢出错误.任何人都可以给我任何见解吗？额外:我也无法弄清楚如何在递归函数中执行计时器,就像我在Non-Recursive中一样.我该如何处理？

public class comparingTimes {
    public static void main(String[] args) {

        double num = 10000;
        double result;
        nonRec(num); 
        result = rec(num);      
        System.out.printf("Rec %.0f",(result));
    }
    public static void nonRec(double num)
    {
    double resultNum = 1;
    double total = 0;
    long startTime = System.currentTimeMillis();
    long endTime;
    for (double i = 1; i < num; i++)
     {
        total += i * (i+1);
        if (i == resultNum)
        {
            endTime = System.currentTimeMillis();
            System.out.printf("Total execution time: %f seconds - num = %.0f%n", (endTime - startTime)/1000.0, …