当没有足够的内存来抛出OutOfMemoryError时会发生什么？
我知道每个对象都需要堆内存，堆栈上的每个原语/引用都需要堆栈内存。
当我尝试在堆上创建一个对象且没有足够的内存来执行此操作时，JVM会在堆上创建一个java.lang.OutOfMemoryError并将其抛给我。
所以这意味着，这意味着JVM在启动时会保留一些内存。
当这个保留的内存用完时会发生什么（它肯定会用完，下面的讨论），而且JVM上没有足够的内存来创建java.lang.OutOfMemoryError的实例？
它刚刚挂起吗？或者他会给我一个null，因为new一个OOM实例没有记忆？
try {
Object o = new Object();
// and operations which require memory (well.. that's like everything)
} catch (java.lang.OutOfMemoryError e) {
// JVM had insufficient memory to create an instance of java.lang.OutOfMemoryError to throw to us
// what next? hangs here, stuck forever?
// or would the machine decide to throw us a "null" ? (since it doesn't have memory to throw us anything more useful than a null)
e.printStackTrace(); // e.printStackTrace() requires memory too.. =X
}
==
为什么JVM无法保留足够的内存？
无论保留多少内存，如果JVM无法“回收”该内存，该内存仍有可能用完：
try {
Object o = new Object();
} catch (java.lang.OutOfMemoryError e) {
// JVM had 100 units of "spare memory". 1 is used to create this OOM.
try {
e.printStackTrace();
} catch (java.lang.OutOfMemoryError e2) {
// JVM had 99 units of "spare memory". 1 is used to create this OOM.
try {
e.printStackTrace();
} catch (java.lang.OutOfMemoryError e3) {
// JVM had 98 units of "spare memory". 1 is used to create this OOM.
try {
e.printStackTrace();
} catch (java.lang.OutOfMemoryError e4) {
// JVM had 97 units of "spare memory". 1 is used to create this OOM.
try {
e.printStackTrace();
} catch (java.lang.OutOfMemoryError e5) {
// JVM had 96 units of "spare memory". 1 is used to create this OOM.
try {
e.printStackTrace();
} catch (java.lang.OutOfMemoryError e6) {
// JVM had 95 units of "spare memory". 1 is used to create this OOM.
e.printStackTrace();
//........the JVM can't have infinite reserved memory, he's going to run out in the end
}
}
}
}
}
}
或者更简洁：
private void OnOOM(java.lang.OutOfMemoryError e) {
try {
e.printStackTrace();
} catch (java.lang.OutOfMemoryError e2) {
OnOOM(e2);
}
}
11 个答案:
答案 0 :(得分：144)
JVM永远不会耗尽内存。它预先对堆栈进行内存计算。
Structure of the JVM, Chapter 3，第3.5.2节说明：
- 如果可以动态扩展Java虚拟机堆栈，并尝试进行扩展，但可以使内存不足 实现扩展，或者如果内存不足 可用于为新的创建初始Java虚拟机堆栈 线程，Java虚拟机抛出
OutOfMemoryError。
对于堆，第3.5.3节。
- 如果计算需要的堆数超过自动存储管理系统（Java虚拟机）可用的堆 抛出
OutOfMemoryError。
因此，它在分配对象之前预先进行计算。
JVM尝试为名为Permanent Generation region（或PermSpace）的内存中的对象分配内存。如果分配失败（即使在JVM调用垃圾收集器尝试和分配可用空间之后），它也会抛出OutOfMemoryError。即使异常也需要一个内存空间，因此错误将被无限期抛出。
Further reading.？此外，OutOfMemoryError可能出现在不同的JVM structure.
答案 1 :(得分：64)
Graham Borland seems to be right：至少我的 JVM显然重用了OutOfMemoryErrors。为了测试这个，我写了一个简单的测试程序：
class OOMTest {
private static void test (OutOfMemoryError o) {
try {
for (int n = 1; true; n += n) {
int[] foo = new int[n];
}
} catch (OutOfMemoryError e) {
if (e == o)
System.out.println("Got the same OutOfMemoryError twice: " + e);
else test(e);
}
}
public static void main (String[] args) {
test(null);
}
}
运行它会产生此输出：
$ javac OOMTest.java && java -Xmx10m OOMTest
Got the same OutOfMemoryError twice: java.lang.OutOfMemoryError: Java heap space
$ java -version
java version "1.6.0_26"
Java(TM) SE Runtime Environment (build 1.6.0_26-b03)
Java HotSpot(TM) 64-Bit Server VM (build 20.1-b02, mixed mode)
编辑：我试图了解如果我迫使 JVM使用以下程序完全耗尽内存将会发生什么：
class OOMTest2 {
private static void test (int n) {
int[] foo;
try {
foo = new int[n];
test(n * 2);
}
catch (OutOfMemoryError e) {
test((n+1) / 2);
}
}
public static void main (String[] args) {
test(1);
}
}
事实证明，它似乎永远循环。但是，奇怪的是，尝试使用 Ctrl + C 终止程序不起作用，但只提供以下消息：
Java HotSpot(TM) 64-Bit Server VM warning: Exception java.lang.OutOfMemoryError occurred dispatching signal SIGINT to handler- the VM may need to be forcibly terminated
答案 2 :(得分：41)
大多数运行时环境将在启动时预分配，或以其他方式保留足够的内存来处理内存不足情况。我想大多数理智的JVM实现都会这样做。
答案 3 :(得分：23)
上次我使用Java并使用调试器时，堆检查器显示JVM在启动时分配了一个OutOfMemoryError实例。换句话说，它会在程序有机会开始消耗之前分配对象，更不用说耗尽内存了。
答案 4 :(得分：12)
从JVM规范，第3.5.2节：
如果可以动态扩展Java虚拟机堆栈，并且尝试进行扩展，但可以使内存不足以实现扩展，或者可以使内存不足以为新线程创建初始Java虚拟机堆栈， Java虚拟机会抛出
OutOfMemoryError。
每个Java虚拟机都必须保证它会抛出OutOfMemoryError。这意味着，它必须能够创建OutOfMemoryError的实例（或者事先创建），即使没有剩余堆空间。
虽然没有必要保证，但是还有足够的内存来捕获它并打印出漂亮的堆栈跟踪......
<强>加成
您添加了一些代码来表明，如果必须抛出多个OutOfMemoryError，JVM可能会耗尽堆空间。但是这样的实施会违反上述要求。
不要求OutOfMemoryError的抛出实例是唯一的或按需创建的。 JVM可以在启动期间准备一个OutOfMemoryError实例，并在堆空间用完时抛出它 - 这在正常环境中是一次。换句话说：我们看到的OutOfMemoryError实例可能是单身。
答案 5 :(得分：11)
有趣的问题:-)。虽然其他人对理论方面给出了很好的解释，但我决定尝试一下。这是在Oracle JDK 1.6.0_26，Windows 7 64位上。
测试设置
我写了一个简单的程序来耗尽内存（见下文）。
程序只是创建一个静态java.util.List，并保持填充新的字符串，直到抛出OOM。然后它捕获它并继续填充无限循环（可怜的JVM ......）。
测试结果
从输出中可以看出，抛出OOME的前四次，它带有堆栈跟踪。之后，如果调用java.lang.OutOfMemoryError: Java heap space，后续OOME仅打印printStackTrace()。
显然，如果可以的话，JVM会努力打印堆栈跟踪，但如果内存非常紧张，它就会省略跟踪，就像其他答案所暗示的那样。
同样有趣的是OOME的哈希码。请注意，前几个OOME都有不同的哈希值。一旦JVM开始省略堆栈跟踪，哈希值总是相同的。这表明JVM将尽可能长时间地使用新的（预分配的？）OOME实例，但是如果推送，它将只重用相同的实例，而不是没有任何东西可以抛出。
<强>输出
注意：我截断了一些堆栈跟踪以使输出更易于阅读（“[...]”）。
iteration 0
iteration 100000
iteration 200000
iteration 300000
iteration 400000
iteration 500000
iteration 600000
iteration 700000
iteration 800000
iteration 900000
iteration 1000000
iteration 1100000
iteration 1200000
iteration 1300000
iteration 1400000
iteration 1500000
Ouch: java.lang.OutOfMemoryError: Java heap space; hash: 1069480624
Keep on trying...
java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Unknown Source)
at java.util.Arrays.copyOf(Unknown Source)
at java.util.ArrayList.ensureCapacity(Unknown Source)
at java.util.ArrayList.add(Unknown Source)
at testsl.Div.gobbleUpMemory(Div.java:23)
at testsl.Div.exhaustMemory(Div.java:12)
at testsl.Div.main(Div.java:7)
java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Unknown Source)
[...]
Ouch: java.lang.OutOfMemoryError: Java heap space; hash: 616699029
Keep on trying...
java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Unknown Source)
[...]
Ouch: java.lang.OutOfMemoryError: Java heap space; hash: 2136955031
Keep on trying...
java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Unknown Source)
[...]
Ouch: java.lang.OutOfMemoryError: Java heap space; hash: 1535562945
Keep on trying...
java.lang.OutOfMemoryError: Java heap space
Ouch: java.lang.OutOfMemoryError: Java heap space; hash: 1734048134
Keep on trying...
Ouch: java.lang.OutOfMemoryError: Java heap space; hash: 1734048134
Keep on trying...
java.lang.OutOfMemoryError: Java heap space
Ouch: java.lang.OutOfMemoryError: Java heap space; hash: 1734048134
Keep on trying...
[...]
该计划
public class Div{
static java.util.List<String> list = new java.util.ArrayList<String>();
public static void main(String[] args) {
exhaustMemory();
}
private static void exhaustMemory() {
try {
gobbleUpMemory();
} catch (OutOfMemoryError e) {
System.out.println("Ouch: " + e+"; hash: "+e.hashCode());
e.printStackTrace();
System.out.println("Keep on trying...");
exhaustMemory();
}
}
private static void gobbleUpMemory() {
for (int i = 0; i < 10000000; i++) {
list.add(new String("some random long string; use constructor to force new instance"));
if (i % 10000000== 0) {
System.out.println("iteration "+i);
}
}
}
}
答案 6 :(得分：6)
我很确定，JVM会确保它至少有足够的内存来在内存不足之前抛出异常。
答案 7 :(得分：4)
您似乎混淆了JVM保留的虚拟内存，其中JVM运行Java程序，主机操作系统的本机内存中JVM作为本机进程运行。机器上的JVM在由OS管理的内存中运行，而不是在JVM保留用于运行Java程序的内存中运行。
进一步阅读：
- http://java.sys-con.com/node/1229281
- http://publib.boulder.ibm.com/infocenter/javasdk/tools/index.jsp?topic=%2Fcom.ibm.java.doc.igaa%2F_1vg000121410cbe-1195c23a635-7ffa_1001.html
作为最后一点，尝试捕获 java.lang.Error （及其后代类）以打印堆栈跟踪可能不会给你任何有用的信息。你想要一个堆转储。
答案 8 :(得分：4)
表示试图违反托管内存环境边界的异常由所述环境的运行时处理，在本例中为JVM。 JVM是它自己的进程，它运行你的应用程序的IL。如果程序尝试进行调用以扩展调用堆栈超出限制，或者分配比JVM可以保留的内存更多的内存，则运行时本身将注入异常，这将导致调用堆栈被展开。无论程序当前需要多少内存，或者调用堆栈的深度如何，JVM都会在其自己的进程边界内分配足够的内存来创建所述异常并将其注入到代码中。
答案 9 :(得分：4)
为了进一步澄清@Graham Borland的答案，功能上，JVM在启动时做到了这一点：
private static final OutOfMemoryError OOME = new OutOfMemoryError();
稍后，JVM执行以下Java字节码之一：'new'，'anewarray'或'multianewarray'。该指令使JVM在内存不足的情况下执行许多步骤：
- 调用本机函数，例如
allocate()。allocate()尝试为某个特定类或数组的新实例分配内存。 - 该分配请求失败，因此JVM调用另一个本地函数，比如
doGC()，它试图进行垃圾收集。 - 当该函数返回时，
allocate()会再次尝试为实例分配内存。 - 如果失败（*），那么在allocate（）中的JVM只执行
throw OOME;，指的是它在启动时实例化的OOME。请注意，它不必分配OOME，只是引用它。
显然，这些不是文字步骤;它们在实现中会从JVM变为JVM，但这是高层次的想法。
（*）在失败之前，这里发生了大量的工作。 JVM将尝试清除SoftReference对象，在使用分代收集器时尝试直接分配到tenured generation，以及其他可能的事情，例如finalization。
答案 10 :(得分：2)
说JVM将预先分配OutOfMemoryErrors的答案确实是正确的
除了通过激发内存不足情况进行测试之外，我们还可以检查任何JVM的堆（我使用了一个只是睡眠的小程序，使用来自Java 8更新31的Oracle的Hotspot JVM运行它）。 p>
使用jmap我们看到OutOfMemoryError似乎有9个实例（即使我们有足够的内存）：
> jmap -histo 12103 | grep OutOfMemoryError 71: 9 288 java.lang.OutOfMemoryError 170: 1 32 [Ljava.lang.OutOfMemoryError;
然后我们可以生成堆转储：
> jmap -dump:format=b,file=heap.hprof 12315
并使用Eclipse Memory Analyzer打开它，其中OQL查询显示JVM实际上似乎为所有可能的消息预分配OutOfMemoryErrors：
实际预先分配这些can be found here的Java 8 Hotspot JVM的代码，看起来像这样（省略了一些部分）：
...
// Setup preallocated OutOfMemoryError errors
k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_OutOfMemoryError(), true, CHECK_false);
k_h = instanceKlassHandle(THREAD, k);
Universe::_out_of_memory_error_java_heap = k_h->allocate_instance(CHECK_false);
Universe::_out_of_memory_error_metaspace = k_h->allocate_instance(CHECK_false);
Universe::_out_of_memory_error_class_metaspace = k_h->allocate_instance(CHECK_false);
Universe::_out_of_memory_error_array_size = k_h->allocate_instance(CHECK_false);
Universe::_out_of_memory_error_gc_overhead_limit =
k_h->allocate_instance(CHECK_false);
...
if (!DumpSharedSpaces) {
// These are the only Java fields that are currently set during shared space dumping.
// We prefer to not handle this generally, so we always reinitialize these detail messages.
Handle msg = java_lang_String::create_from_str("Java heap space", CHECK_false);
java_lang_Throwable::set_message(Universe::_out_of_memory_error_java_heap, msg());
msg = java_lang_String::create_from_str("Metaspace", CHECK_false);
java_lang_Throwable::set_message(Universe::_out_of_memory_error_metaspace, msg());
msg = java_lang_String::create_from_str("Compressed class space", CHECK_false);
java_lang_Throwable::set_message(Universe::_out_of_memory_error_class_metaspace, msg());
msg = java_lang_String::create_from_str("Requested array size exceeds VM limit", CHECK_false);
java_lang_Throwable::set_message(Universe::_out_of_memory_error_array_size, msg());
msg = java_lang_String::create_from_str("GC overhead limit exceeded", CHECK_false);
java_lang_Throwable::set_message(Universe::_out_of_memory_error_gc_overhead_limit, msg());
msg = java_lang_String::create_from_str("/ by zero", CHECK_false);
java_lang_Throwable::set_message(Universe::_arithmetic_exception_instance, msg());
// Setup the array of errors that have preallocated backtrace
k = Universe::_out_of_memory_error_java_heap->klass();
assert(k->name() == vmSymbols::java_lang_OutOfMemoryError(), "should be out of memory error");
k_h = instanceKlassHandle(THREAD, k);
int len = (StackTraceInThrowable) ? (int)PreallocatedOutOfMemoryErrorCount : 0;
Universe::_preallocated_out_of_memory_error_array = oopFactory::new_objArray(k_h(), len, CHECK_false);
for (int i=0; i<len; i++) {
oop err = k_h->allocate_instance(CHECK_false);
Handle err_h = Handle(THREAD, err);
java_lang_Throwable::allocate_backtrace(err_h, CHECK_false);
Universe::preallocated_out_of_memory_errors()->obj_at_put(i, err_h());
}
Universe::_preallocated_out_of_memory_error_avail_count = (jint)len;
}
...
和this code表明JVM将首先尝试使用其中一个预先分配的错误和空间进行堆栈跟踪，然后回退到没有堆栈跟踪的错误：
oop Universe::gen_out_of_memory_error(oop default_err) {
// generate an out of memory error:
// - if there is a preallocated error with backtrace available then return it wth
// a filled in stack trace.
// - if there are no preallocated errors with backtrace available then return
// an error without backtrace.
int next;
if (_preallocated_out_of_memory_error_avail_count > 0) {
next = (int)Atomic::add(-1, &_preallocated_out_of_memory_error_avail_count);
assert(next < (int)PreallocatedOutOfMemoryErrorCount, "avail count is corrupt");
} else {
next = -1;
}
if (next < 0) {
// all preallocated errors have been used.
// return default
return default_err;
} else {
// get the error object at the slot and set set it to NULL so that the
// array isn't keeping it alive anymore.
oop exc = preallocated_out_of_memory_errors()->obj_at(next);
assert(exc != NULL, "slot has been used already");
preallocated_out_of_memory_errors()->obj_at_put(next, NULL);
// use the message from the default error
oop msg = java_lang_Throwable::message(default_err);
assert(msg != NULL, "no message");
java_lang_Throwable::set_message(exc, msg);
// populate the stack trace and return it.
java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(exc);
return exc;
}
}
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？