在Java虚拟机规范中描述了两种异常：

  • 如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverflowError异常
  • 如果虚拟机在扩展栈时无法申请到足够的内存空间，则抛出OutOfMemoryError异常

单线程版

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.super2bai.jvm;

/**
 * VM Args:-Xss128k <br/>
 * The stack size specified is too small, Specify at least 160k<br/>
 * 
 * VM Args:-Xss160k<br/>
 * 运行结果：
 * stackLength=771
 * Exception in thread "main" java.lang.StackOverflowError<br/>
 * at com.super2bai.jvm.JavaVMStackSOF.stackLeak(JavaVMStackSOF.java:19)
 * 
 * @author 2bai
 *
 */
public class JavaVMStackSOF {
	private int stackLength = 1;

	public void stackLeak() {
		stackLength++;
		stackLeak();
	}

	public static void main(String[] args) throws Throwable {
		JavaVMStackSOF vmStackSOF = new JavaVMStackSOF();
		try {
			vmStackSOF.stackLeak();
		} catch (Throwable e) {
			System.out.println("stackLength=" + vmStackSOF.stackLength);
			throw e;
		}
	}
}

在单个线程下，无论是由于栈帧太大还是虚拟机栈容量太小，当内存无法分配时，虚拟机抛出的都是StackOverflowError异常。

多线程版

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package com.super2bai.jvm;

/**
 * -Xss2M
 * 运行代码后，系统无响应，暂无解决办法
 * 
 * @author 2bai
 * 
 * 期望运行结果：
 * Exception in thread "Main" java.lang.OutOfMemoryError:unable to create new native thread
 */
public class JavaVMStackOOM {
	private void dontStop() {
		while (true) {
		}
	}

	public void stackLeakByThread() {
		while (true) {
			Thread thread = new Thread(new Runnable() {
				@Override
				public void run() {
					dontStop();
				}
			});
			thread.start();
		}
	}

	public static void main(String[] args) throws Throwable {
		JavaVMStackOOM oom = new JavaVMStackOOM();
		oom.stackLeakByThread();
	}
}

通过不断地建立线程的方式倒是可以产生内存溢出异常，此处未实验成功，系统一直无响应，望大佬指教，但是这样产生的内存溢出异常与栈空间是否足够大并不存在任何联系，或者准确地说，在这种情况下，为每个线程的栈分配的内存越大，反而越容易产生内存溢出异常。

其实原因不难理解，操作系统分配给每个进程的内存是有限的，譬如32位的Windows限制为2GB。虚拟机提供了参数来控制Java堆和方法区的这两部分内存的最大值。

剩余的内存 = 2GB(系统限制) - Xmx(最大堆容量) - MaxPermSize(最大方法区容量)。

程序计数器消耗内存很小，可以忽略掉。

如果虚拟机进程本身耗费的内存不计算在内，剩下的内存就由虚拟机栈和本地方法栈使用。

每个线程分配到的栈容量越大，可以建立的线程数自然就越少，建立线程时就越容易把剩下的内存耗尽。