太阳城娱乐电子游戏在《Java凭空机步履》的法例里太阳城娱乐电子游戏，除了面孔计数器外，凭空机内存的其他几个运行时区域皆有发生 OutOfMemoryError 特殊的可能。

[[332758]]

本篇主要包括如下 OOM 的先容和示例：

咱们常说的 OOM 特殊，其实是 Error

一. StackOverflowError

1.1 写个 bug

public class StackOverflowErrorDemo {      public static void main(String[] args) {         javaKeeper();     }      private static void javaKeeper() {         javaKeeper();     } } 

JVM 凭空机栈是有深度的，在实行方法的时候会伴跟着入栈和出栈，上边的方法不错看到，main 方法实行后阻挡的递归，早晚把栈撑爆了

Exception in thread "main" java.lang.StackOverflowError  at oom.StackOverflowErrorDemo.javaKeeper(StackOverflowErrorDemo.java:15) 

1.2 原因分析

1.3 惩办决策

二. Java heap space

Java 堆用于存储对象实例，咱们独一持续的创建对象，而况保证 GC Roots 到对象之间有可达旅途来幸免 GC 吊销这些对象，那跟着对象数量的加多，总容量涉及堆的最大容量罢休后就会产生内存溢出特殊。

Java 堆内存的 OOM 特殊是实质应用中最常见的内存溢出特殊。

2.1 写个 bug

/**  * JVM参数：-Xmx12m  */ public class JavaHeapSpaceDemo {      static final int SIZE = 2 * 1024 * 1024;      public static void main(String[] a) {         int[] i = new int[SIZE];     } } 

代码试图分拨容量为 2M 的 int 数组，如若指定启动参数 -Xmx12m，分拨内存就不够用，就近似于将 XXXL 号的对象，往 S 号的 Java heap space 里面塞。

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space  at oom.JavaHeapSpaceDemo.main(JavaHeapSpaceDemo.java:13) 

2.2 原因分析

2.3 惩办决策

针对大部分情况，凡俗只需要通过 -Xmx 参数调高 JVM 堆内存空间即可。如若仍然莫得惩办，不错参考以下情况作念进一步处理：

口试官：说说内存泄漏和内存溢出

加送个学问点，三连的终将成为大神~~

内存泄漏和内存溢出

内存溢出(out of memory)，是指面孔在央求内存时，莫得填塞的内存空间供其使用，出现out of memory;比如央求了一个 Integer，但给它存了 Long 才能存下的数，那便是内存溢出。

内存泄漏( memory leak)，是指面孔在央求内存后，无法开释已央求的内存空间，一次内存泄漏危害不错忽略，但内存泄漏堆积后果很严重，无论若干内存，早晚会被占光。

皇冠hg86a

memory leak 最终会导致 out of memory!

三、GC overhead limit exceeded

JVM 内置了垃圾回收机制GC，是以行为 Javaer 的咱们不需要手工编写代码来进行内存分拨和开释，但是当 Java 程度破耗 98% 以上的技能实行 GC，但只收复了不到 2% 的内存，且该动作连气儿重叠了 5 次，就会抛出 java.lang.OutOfMemoryError:GC overhead limit exceeded 诞妄(俗称：垃圾回收上面)。肤浅地说，便是应用面孔依然基本破钞了通盘可用内存， GC 也无法回收。

假如不抛出 GC overhead limit exceeded 诞妄，那 GC 计帐的那么一丢丢内存很快就会被再次填满，迫使 GC 再次实行，这样恶性轮回，CPU 使用率 100%，而 GC 没什么后果。

3.1 写个 bug

出现这个诞妄的实例，其实咱们写个无尽轮回，往 List 或 Map 加数据就会一直 Full GC，直到扛不住，这里用一个退却易发现的栗子。咱们往 map 中添加 1000 个元素。

/**  * JVM 参数： -Xmx14m -XX:+PrintGCDetails  */ public class KeylessEntry {      static class Key {         Integer id;          Key(Integer id) {             this.id = id;         }          @Override         public int hashCode() {             return id.hashCode();         }     }      public static void main(String[] args) {         Map m = new HashMap();         while (true){             for (int i = 0; i < 1000; i++){                 if (!m.containsKey(new Key(i))){                     m.put(new Key(i)， "Number:" + i);                 }             }             System.out.println("m.size()=" + m.size());         }     } } 

... m.size()=54000 m.size()=55000 m.size()=56000 Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded 

从输出驱逐不错看到，咱们的罢休 1000 条数据莫得起作用，map 容量远特出了 1000，而且临了也出现了咱们思要的诞妄，这是因为类 Key 只重写了 hashCode() 方法，却莫得重写 equals() 方法，咱们在使用 containsKey() 方法其实就出现了问题，于是就会一直往 HashMap 中添加 Key，直至 GC 皆计帐不掉。

 口试官又来了：说一下HashMap旨趣以及为什么需要同期末端equals和hashcode

实行这个面孔的最终诞妄，和 JVM 竖立也会联系系，如若诞生的堆内存极度小，皇冠开户会成功报 Java heap space。算是被这个诞妄截胡了，是以就怕，在资源受限的情况下，无法准确展望面孔会死于哪种具体的原因。

3.2 惩办决策

四、Direct buffer memory

咱们使用 NIO 的时候频繁需要使用 ByteBuffer 来读取或写入数据，这是一种基于 Channel(通谈) 和 Buffer(缓冲区)的 I/O 方式，它不错使用 Native 函数库成功分拨堆外内存，然后通过一个存储在 Java 堆里面的 DirectByteBuffer 对象行为这块内存的援用进行操作。这样在一些场景就幸免了 Java 堆和 Native 中来恢复制数据，是以性能会有所普及。

Java 允许应用面孔通过 Direct ByteBuffer 成功探望堆外内存，许多高性能面孔通过 Direct ByteBuffer 相连内存映射文献(Memory Mapped File)末端高速 IO。

4.1 写个 bug

如若持续分拨腹地内存，堆内存很少使用，那么 JVM 就不需要实行 GC，DirectByteBuffer 对象就不会被回收，这时天然堆内存充足，但腹地内存可能依然不够用了，就会出现 OOM，腹地成功内存溢出。

/**  *  VM Options：-Xms10m，-Xmx10m，-XX:+PrintGCDetails -XX:MaxDirectMemorySize=5m  */ public class DirectBufferMemoryDemo {      public static void main(String[] args) {         System.out.println("maxDirectMemory is:"+sun.misc.VM.maxDirectMemory() / 1024 / 1024 + "MB");          //ByteBuffer buffer = ByteBuffer.allocate(6*1024*1024);         ByteBuffer buffer = ByteBuffer.allocateDirect(6*1024*1024);      } } 

最大成功内存，默许是电脑内存的 1/4，是以咱们设小点，然后使用成功内存特出这个值，就会出现 OOM。

maxDirectMemory is:5MB Exception in thread "main" java.lang.OutOfMemoryError: Direct buffer memory 

4.2 惩办决策

五、Unable to create new native thread

每个 Java 线程皆需要占用一定的内存空间，当 JVM 向底层操作系统请求创建一个新的 native 线程时，如若莫得填塞的资源分拨就会报此类诞妄。

5.1 写个 bug

public static void main(String[] args) {   while(true){     new Thread(() -> {       try {         Thread.sleep(Integer.MAX_VALUE);       } catch(InterruptedException e) { }     }).start();   } } Error occurred during initialization of VM java.lang.OutOfMemoryError: unable to create new native thread 

5.2 原因分析

5.3 惩办决策

思主见镌汰面孔中创建线程的数量，分析应用是否竟然需要创建这样多线程

如若如实需要创建许多线程，调高 OS 层面的线程最大数：实行 ulimia-a 检察最大线程数罢休，使用 ulimit-u xxx 调遣最大线程数罢休

六、Metaspace

JDK 1.8 之前会出现 Permgen space，该诞妄暗示遥远代(Permanent Generation)已用满，凡俗是因为加载的 class 数量太多或体积太大。跟着 1.8 中遥远代的取消，就不会出现这种特殊了。

Metaspace 是方法区在 HotSpot 中的末端，它与遥远代最大的别离在于，元空间并不在凭空机内存中而是使用腹地内存，但是腹地内存也有打满的时候，是以也会有特殊。

6.1 写个 bug

/**  * JVM Options: -XX:MetaspaceSize=10m -XX:MaxMetaspaceSize=10m  */ public class MetaspaceOOMDemo {      public static void main(String[] args) {          while (true) {             Enhancer enhancer = new Enhancer();             enhancer.setSuperclass(MetaspaceOOMDemo.class);             enhancer.setUseCache(false);             enhancer.setCallback((MethodInterceptor) (o， method， objects， methodProxy) -> {                 //动态代理创建对象                 return methodProxy.invokeSuper(o， objects);             });             enhancer.create();         }     } } 

借助 Spring 的 GCLib 末端动态创建对象

Exception in thread "main" org.springframework.cglib.core.CodeGenerationException: java.lang.OutOfMemoryError-->Metaspace 

6.2 惩办决策

方法区溢出亦然一种常见的内存溢出特殊，在频繁运行时生成精深动态类的应用场景中，就应该极度和顺这些类的回收情况。这类场景除了上边的 GCLib 字节码增强和动态讲话外，常见的还有，精深 JSP 或动态产生 JSP 文献的应用(旷古时期的传统软件行业可能会有)、基于 OSGi 的应用(即使归并个类文献，被不同的加载器加载也会视为不同的类)等。

方法区在 JDK8 中一般不太容易产生，HotSpot 提供了一些参数来诞生元空间，不错起到督察作用

七、Requested array size exceeds VM limit

7.1 写个 bug

public static void main(String[] args) {   int[] arr = new int[Integer.MAX_VALUE]; } 

这个比拟肤浅，建个超等大数组就会出现 OOM，未几说了

Exception in thread "main" java.lang.OutOfMemoryError: Requested array size exceeds VM limit 

JVM 罢休了数组的最大长度，该诞妄暗示面孔请求创建的数组特出最大长度罢休。

JVM 在为数组分拨内存前，会查验要分拨的数据结构在系统中是否可寻址，凡俗为 Integer.MAX_VALUE-2。

此类问题比拟阑珊，凡俗需要查验代码，证明业务是否需要创建如斯大的数组，是否不错拆分为多个块，分批实行。

八、Out of swap space

启动 Java 应用面孔会分拨有限的内存。此罢休是通过-Xmx和其他近似的启动参数指定的。

在 JVM 请求的总内存大于可用物理内存的情况下，操作系统发轫将内容从内存换出到硬盘驱动器。

该诞妄暗示通盘可用的凭空内存已被破钞。凭空内存(Virtual Memory)由物理内存(Physical Memory)和交换空间(Swap Space)两部分构成。

这种诞妄没见过~~~

九、Kill process or sacrifice child

操作系统是建立在经过主见之上的。这些程度由几个内核功课认真，其中一个名为“ Out of memory Killer”，它会在可用内存极低的情况下“杀死”(kill)某些程度。OOM Killer 会对通盘程度进行打分，然后将评分较低的程度“杀死”，具体的评分法例不错参考 Surviving the Linux OOM Killer。

不同于其他的 OOM 诞妄， Killprocessorsacrifice child 诞妄不是由 JVM 层面触发的，而是由操作系统层面触发的。

[扫码下载app，中过数字彩1千万以上的专家都在这儿！]

9.1 原因分析

默许情况下，Linux 内核允许程度央求的内存总量大于系统可用内存，通过这种“错峰复用”的方式不错更有用的运用系统资源。

然则，这种方式也会无可幸免地带来一定的“超卖”风险。举例某些程度捏续占用系统内存，然后导致其他程度莫得可用内存。此时，系统将自动激活 OOM Killer，寻找评分低的程度，并将其“杀死”，开释内存资源。

9.2 惩办决策

临了附上一张“涯海”大神的图

《深切贯通 Java 凭空机 第 3 版》

https://plumbr.io/outofmemoryerror

https://yq.aliyun.com/articles/711191

https://github.com/StabilityMan/StabilityGuide/blob/master/docs/diagnosis/jvm/exception

本文转载自微信公众号「JavaKeeper」，作家海星 。转载本文请商量 JavaKeeper公众号。

原文结合：https://mp.weixin.qq.com/s/gIJvtd8rrZz6ttaoGLddLg