如何增加Java堆栈大小？
我问了这个问题，以了解如何增加JVM中的运行时调用堆栈大小。 我已经得到了一个答案，而且我也得到了很多有用的答案和评论，这些答案和评论与Java如何处理需要大型运行时堆栈的情况相关。 我已经回答了问题的总结。
最初我想增加JVM堆栈的大小，所以像没有StackOverflowError运行的程序。
public class TT { public static long fact(int n) { return n < 2 ? 1 : n * fact(n - 1); } public static void main(String[] args) { System.out.println(fact(1 << 15)); } }
相应的configuration设置是具有足够大的值的java -Xss...命令行标志。 对于上面的程序TT ，它可以像OpenJDK的JVM一样工作：
$ javac TT.java $ java -Xss4m TT
其中一个答案也指出-X...标志是依赖于实现的。 我正在使用
java version "1.6.0_18" OpenJDK Runtime Environment (IcedTea6 1.8.1) (6b18-1.8.1-0ubuntu1~8.04.3) OpenJDK 64-Bit Server VM (build 16.0-b13, mixed mode)
也可以为一个线程指定一个大堆栈（请参阅其中一个答案）。 这是比java -Xss...推荐，以避免浪费内存的线程不需要它。
我很好奇上面的程序需要多大的堆栈，所以我运行它增加了：
- -Xss4m可以满足
fact(1 << 15) - -Xss5m可以满足
fact(1 << 17) - -Xss7m可以满足
fact(1 << 18) - -Xss9m可以满足
fact(1 << 19) - -Xss18m可以满足
fact(1 << 20) - -Xss35m可以满足
fact(1 << 21) - -Xss68m可以满足
fact(1 << 22) - -Xss129m可以满足
fact(1 << 23) - -Xss258m可以满足
fact(1 << 24) - -Xss515m可以满足
fact(1 << 25)
从上面的数字看来，Java对于上面的函数使用每个栈帧大约16个字节，这是合理的。
上面的枚举包含的可以 是足够的 ，因为堆栈需求是不确定的：使用相同的源文件多次运行它，相同的-Xss...有时成功，有时会产生StackOverflowError 。 例如，对于1 20， -Xss18m已经足够用于10次中的7次，并且-Xss19m也不总是足够的，但是-Xss20m已经足够了（100次全部100次）。 垃圾收集，JIT踢，或其他事情导致这种不确定的行为？
在StackOverflowError打印的堆栈跟踪（可能还有其他例外情况）只显示运行时堆栈的最新的1024个元素。 下面的答案演示了如何计算到达的确切深度（可能比1024大很多）。
许多回应者指出，考虑替代的，相同algorithm的较less堆栈实现是一个好的和安全的编码实践。 一般来说，可以将一组recursion函数转换为迭代函数（使用例如Stack对象，而不是在运行时栈上填充）。 对于这个特定的factfunction，转换它是相当容易的。 我的迭代版本如下所示：
public class TTIterative { public static long fact(int n) { if (n < 2) return 1; if (n > 65) return 0; // Enough powers of 2 in the product to make it (long)0. long f = 2; for (int i = 3; i <= n; ++i) { f *= i; } return f; } public static void main(String[] args) { System.out.println(fact(1 << 15)); } }
仅供参考，正如上面的迭代解决scheme所示， fact函数无法计算65以上（实际上，甚至高于20）的确切因子数，因为Java内置typeslong会溢出。 重构的fact所以它会返回一个BigInteger而不是long也会产生大input的确切结果。
嗯…它适用于我和远远less于999MB的堆栈：
> java -Xss4m Test 0
（Windows JDK 7，构build17.0-b05客户端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选项。 在非热点虚拟机上可能有些不同，因为到JVM的-X参数是特定于分布的，IIRC。
在热点上，如果你想把大小设置为16兆，这看起来像java -Xss16M 。
inputjava -X -help如果你想查看所有可以传入的特定于分发的JVM参数。我不确定这是否和其他JVM一样，但是它打印所有的热点特定参数。
对于它的价值 – 我会build议限制你在Java中使用recursion方法。 在优化它们时不是太好，因为JVM不支持尾recursion（请参阅JVM是否阻止尾调用优化？ ）。 尝试重构上面的因子代码，以使用while循环而不是recursion方法调用。
控制进程内堆栈大小的唯一方法是启动一个新的线程。 但是你也可以用-Xss参数创build一个自调用的子java进程。
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); } } }
因为你急于避免一切合理的方法，所以很难给出一个合理的解决scheme。 重构一行代码是可行的解决scheme。
注意：使用-Xss设置每个线程的堆栈大小，这是一个非常糟糕的主意。
另一种方法是通过字节码操作来更改代码，如下所示：
public static long fact(int n) { return n < 2 ? n : n > 127 ? 0 : n * fact(n - 1); }
因为n> 127的每个答案都是0.这样可以避免更改源代码。
添加此选项
–driver-java-options -Xss512m
到你的spark-submit命令将解决这个问题。
奇怪的！ 你说你想要产生1 << 15深度 ???的recursion ！
我build议不要尝试它。 堆栈的大小将是2^15 * sizeof(stack-frame) 。 我不知道堆栈大小是多less，但2 ^ 15是32.768。 呃，如果它在1024（2 ^ 10）的时候停下来的话，你将不得不把它做成2 ^ 5倍，比你的实际设置大32倍。
其他海报已经指出如何增加记忆，你可以记忆电话。 我build议，对于许多应用程序，你可以使用斯特林公式近似大n！ 几乎没有内存占用。
在这篇文章中，有一些分析function和代码：
http://threebrothers.org/brendan/blog/stirlings-approximation-formula-clojure/
我做了Anagram excersize ，这就像Count Change问题，但有5万面值（硬币）。 我不确定它可以迭代完成 ，我不在乎。 我只知道-xss选项没有任何作用 – 我总是在1024个堆栈帧之后失败（可能是scala没有把工作交给java或printStackTrace限制，我不知道）。 无论如何，这是不好的select。 你不希望所有的线程在应用程序是可怕的。 但是，我做了一些新的线程（堆栈大小）的实验。 这确实有效，
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)
您会发现堆栈可以以指数级更多的堆栈分配给线程，从而成倍地增长。
试试jvm参数：-Xmx128m
