如何增加Java堆栈的大小?

隐马尔可夫模型。。。它适用于我,堆栈远小于999MB:

> java -Xss4m Test
0

(Windows JDK 7、build 17.0-b05 client VM和Linux JDK 6-与您发布的版本信息相同)

我假设您通过堆栈跟踪中的循环行来计算“1024的深度”?

显然,Throwable中的堆栈跟踪数组长度似乎限制为1024。 请尝试以下程序:

public class Test {

    public static void main(String[] args) {

        try {
            System.out.println(fact(1 << 15));
        }
        catch (StackOverflowError e) {
            System.err.println("true recursion level was " + level);
            System.err.println("reported recursion level was " +
                               e.getStackTrace().length);
        }
    }

    private static int level = 0;
    public static long fact(int n) {
        level++;
        return n < 2 ? n : n * fact(n - 1);
    }
}

如果您想使用线程堆栈大小,您需要查看热点JVM上的-Xss选项。在非热点VM上可能会有所不同,因为JVM的-X参数是特定于分布的IIRC。

在热点上,这看起来像 java -Xss16M 如果你想做16毫克的。

类型 java -X -help

Does the JVM prevent tail call optimizations? ). 尝试重构上面的阶乘代码,以使用while循环而不是递归方法调用。

控制进程内堆栈大小的唯一方法是启动一个新进程 Thread -Xss 参数。

public class TT {
    private static int level = 0;

    public static long fact(int n) {
        level++;
        return n < 2 ? n : n * fact(n - 1);
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(null, null, "TT", 1000000) {
            @Override
            public void run() {
                try {
                    level = 0;
                    System.out.println(fact(1 << 15));
                } catch (StackOverflowError e) {
                    System.err.println("true recursion level was " + level);
                    System.err.println("reported recursion level was "
                            + e.getStackTrace().length);
                }
            }

        };
        t.start();
        t.join();
        try {
            level = 0;
            System.out.println(fact(1 << 15));
        } catch (StackOverflowError e) {
            System.err.println("true recursion level was " + level);
            System.err.println("reported recursion level was "
                    + e.getStackTrace().length);
        }
    }

}

添加此选项

--driver-java-options -Xss512m

注意:使用-Xss设置每个线程的堆栈大小,这是一个非常糟糕的主意。

另一种方法是字节码操作,改变代码如下;

public static long fact(int n) { 
    return n < 2 ? n : n > 127 ? 0 : n * fact(n - 1); 
}

如果n>127的每个答案都是0。这样可以避免更改源代码。

我做的 Anagram excersize ,就像 Count Change 有问题,但有5万面额(硬币)。我是 not sure that it can be done iteratively

  def measureStackDepth(ss: Long): Long = {
    var depth: Long = 0
      val thread: Thread = new Thread(null, new Runnable() {
        override def run() {
          try {
          def sum(n: Long): Long = {depth += 1; if (n== 0) 0 else sum(n-1) + 1}
          println("fact = " + sum(ss * 10))
          } catch {
            case e: StackOverflowError => // eat the exception, that is expected
          }
        }
      }, "deep stack for money exchange", ss)
      thread.start()
      thread.join()
    depth
  }                                               //> measureStackDepth: (ss: Long)Long


  for (ss <- (0 to 10)) println("ss = 10^" +  ss + " allows stack of size " -> measureStackDepth((scala.math.pow (10, ss)).toLong) )
                                                  //> fact = 10
                                                  //| (ss = 10^0 allows stack of size ,11)
                                                  //| fact = 100
                                                  //| (ss = 10^1 allows stack of size ,101)
                                                  //| fact = 1000
                                                  //| (ss = 10^2 allows stack of size ,1001)
                                                  //| fact = 10000
                                                  //| (ss = 10^3 allows stack of size ,10001)
                                                  //| (ss = 10^4 allows stack of size ,1336)
                                                  //| (ss = 10^5 allows stack of size ,5456)
                                                  //| (ss = 10^6 allows stack of size ,62736)
                                                  //| (ss = 10^7 allows stack of size ,623876)
                                                  //| (ss = 10^8 allows stack of size ,6247732)
                                                  //| (ss = 10^9 allows stack of size ,62498160)

您可以看到,当向线程分配更多的堆栈时,堆栈可以指数级地增长得更深。

1<<15深度的递归

我建议不要尝试。堆栈的大小将是 2^15 * sizeof(stack-frame) . 我不知道堆栈帧大小是多少,但2^15是32.768。差不多。。。好吧,如果它停在1024(2^10),你必须使它大2^5倍,它是,32倍于你的实际设置。

看看这篇文章,它对函数和代码进行了一些分析:

http://threebrothers.org/brendan/blog/stirlings-approximation-formula-clojure/