🍀 java.lang.StackOverflowError
package com.brian.interview.study.jvm.oom;
/**
* Copyright (c) 2020 ZJU All Rights Reserved
* <p>
* Project: JavaSomeDemo
* Package: com.brian.interview.study.jvm.oom
* Version: 1.0
* <p>
* Created by Brian on 2020/2/15 12:50
*/
public class StackOverflowErrorDemo {
public static void main(String[] args) {
stackOverflowError();
}
private static void stackOverflowError() {
stackOverflowError(); // Exception in thread "main" java.lang.StackOverflowError
}
}
🍀 java.lang.OutOfMemoryError: Java heap space
package com.brian.interview.study.jvm.oom;
import java.util.Random;
/**
* Copyright (c) 2020 ZJU All Rights Reserved
* <p>
* Project: JavaSomeDemo
* Package: com.brian.interview.study.jvm.oom
* Version: 1.0
* <p>
* Created by Brian on 2020/2/15 12:56
*/
public class JavaHeapSpaceDemo {
public static void main(String[] args) {
// byte[] bytes = new byte[80 * 1024 * 1024];
String str = "hello";
while (true) {
str += str + new Random().nextInt(11111111) + new Random().nextInt(22222222);
str.intern();
}
// Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
}
}
🍀 java.lang.OutOfMemoryError: GC overhead limit exceeded
JVM參數配置演示
-Xms10m -Xmx10m -XX:MaxDirectMemorySize=5m
GC回收時間過長時會拋出 OutOfMemoryError。過長的定義是, 超過98%的時間用來做GC並且回收了不到2%的對內存
連續多次 GC 都只回收了不到2%的極端情況下才會拋出。假如不拋出 GC overhead limit 錯誤會發生什麼情況呢？
那就是 GC 清理的這麼點內存很快會再次填滿, 迫使 GC 再次執行。這樣就形成惡性循環,
CPU 使用率一直是 100%, 而 GC 卻沒有任何成果。
package com.brian.interview.study.jvm.oom;
/**
* Copyright (c) 2020 ZJU All Rights Reserved
* <p>
* Project: JavaSomeDemo
* Package: com.brian.interview.study.jvm.oom
* Version: 1.0
* <p>
* Created by Brian on 2020/2/15 13:52
*/
import java.util.ArrayList;
import java.util.List;
/**
* JVM參數配置演示
* -Xms10m -Xmx10m -XX:+PrintGCDetails -XX:MaxDirectMemorySize=5m
*
* GC回收時間過長時會拋出 OutOfMemoryError。過長的定義是, 超過98%的時間用來做GC並且回收了不到2%的對內存
* 連續多次 GC 都只回收了不到2%的極端情況下才會拋出。假如不拋出 GC overhead limit 錯誤會發生什麼情況呢？
* 那就是 GC 清理的這麼點內存很快會再次填滿, 迫使 GC 再次執行。這樣就形成惡性循環,
* CPU 使用率一直是 100%, 而 GC 卻沒有任何成果。
*/
public class GCOverheadDemo {
public static void main(String[] args) {
int i = 0;
List<String> list = new ArrayList<>();
try {
while (true) {
list.add(String.valueOf(++i).intern());
}
} catch (Throwable e) {
System.out.println("******************i:" + i);
e.printStackTrace(); // Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
throw e;
}
}
}
🍀 java.lang.OutOfMemoryError: Direct buffer memory
package com.brian.interview.study.jvm.oom;
/**
* Copyright (c) 2020 ZJU All Rights Reserved
* <p>
* Project: JavaSomeDemo
* Package: com.brian.interview.study.jvm.oom
* Version: 1.0
* <p>
* Created by Brian on 2020/2/15 14:06
*/
import java.nio.ByteBuffer;
/**
* 配置參數：
* -Xms10m -Xmx10m -XX:+PrintGCDetails -XX:MaxDirectMemorySize=5m
*
* 故障現象：
* Exception in thread "main" java.lang.OutOfMemoryError: Direct buffer memory
*
* 導致原因：
*
* 寫NIO程序經常使用 ByteBuffer 來讀取或者寫入數據, 這是一種基於通道（Channel）與緩衝區（Buffer）的I/O方式,
* 它可以使用 Native 函數庫直接分配堆外內存, 然後通過一個存儲在 Java 堆裏面的 DirectByteBuffer 對象作爲這塊內存的引用進行操作。
* 這樣能在一些場景中顯著提高性能, 因爲避免了在 Java 堆和 Native 堆中來回複製數據。
*
* ByteBuffer.allocate(capability) 第一種方式是分配 JVM 堆內存, 屬於 GC 管轄範圍, 由於需要拷貝所以速度相對較慢
*
* ByteBuffer.allocateDirect(capability) 第一種方式是分配 OS 本地內存, 不屬於 GC 管轄範圍, 由於不需要內存拷貝所以速度相對較塊。
*
* 但如果不斷分配本地內存, 堆內存很少使用, 那麼 JVM 就不需要執行 GC, DirectByteBuffer 對象們就不會被回收,
* 這時候堆內存充足, 但本地內存可能已經使用光了, 再次嘗試分配本地內存就會出現 OutOfMemoryError, 那程序就直接崩潰了。
*/
public class DirectBufferMemoryDemo {
public static void main(String[] args) {
System.out.println("配置的 maxDirectMemory:" + (sun.misc.VM.maxDirectMemory() / (double) 1024 / 1024) + "MB");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// -XX:MaxDirectMemorySize=5m 我們配置爲5MB, 但實際使用6MB, 故意使壞
ByteBuffer bb = ByteBuffer.allocateDirect(6 * 1024 * 1024);
}
}
🍀 java.lang.OutOfMemoryError: unable to create new native thread
package com.brian.interview.study.jvm.oom;
/**
* Copyright (c) 2020 ZJU All Rights Reserved
* <p>
* Project: JavaSomeDemo
* Package: com.brian.interview.study.jvm.oom
* Version: 1.0
* <p>
* Created by Brian on 2020/2/15 14:36
*/
/**
* 高併發請求服務器時, 經常出現如下異常：java.lang.OutOfMemoryError: unable to create new native thread
* 準確的講該 native thread 異常與對應的平臺有關
*
* 導致原因：
* 1、你的應用創建了太多線程了, 一個應用進程創建多個線程, 超過系統承載極限
* 2、你的服務器並不允許你的應用程序創建這麼多線程, linux 系統默認允許單個進程可以創建的線程數是 1024 個,
* 你的應用創建超過這個數量, 就會報 java.lang.OutOfMemoryError: unable to create new native thread
*
* 解決辦法：
* 1、想辦法降低你應用程序創建線程的數量, 分析應用是否真的需要創建這麼多線程, 如果不是, 改代碼將線程數降到最低
* 2、對於有的應用, 確定需要創建很多線程, 遠超過 linux 系統的默認 1024 個線程的限制, 可以通過修改 linux 服務器配置, 擴大 linux 默認限制
*/
public class UnableCreateNewThreadDemo {
public static void main(String[] args) {
for (int i = 1; ; i++) {
System.out.println("***************** i=" + i);
new Thread(() -> {
try {
Thread.sleep(Integer.MAX_VALUE);
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "" + i).start();
}
}
}
📌 非 root 用戶登錄 Linux 系統測試
📌 服務器級別調參調優
vim /etc/security/limits.d/90-nproc.conf
打開後發現除了 root，其他賬號都限制在 1024 個
如果我們想要張三這個用戶運行，希望他生成的線程多一些，我們可以如下配置
🍀 java.lang.OutOfMemoryError: Metaspace
package com.brian.interview.study.jvm.oom;
/**
* Copyright (c) 2020 ZJU All Rights Reserved
* <p>
* Project: JavaSomeDemo
* Package: com.brian.interview.study.jvm.oom
* Version: 1.0
* <p>
* Created by Brian on 2020/2/15 15:14
*/
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* JVM 參數
* -XX:MetaspaceSize=8m -XX:MaxMetaspaceSize=8m
*
* Java 8 及之後的版本使用 Metaspace 來替代永久代。
*
* Metaspace 是方法區在 HotSpot 中的實現, 它與持久代最大的區別在於：Metaspace 並不在虛擬機內存中而是使用本地內存
* 也即在 java8 中, classes metadata(the virtual machines internal presentation of Java class), 被存儲在叫做
* Metaspace 的 native memory
*
* 永久代（java8 後被元空間 Metaspace 取代了）存放了以下信息：
*
* 虛擬機加載的類信息
* 常量池
* 靜態變量
* 即時編譯後的代碼
*
* 模擬 Metaspace 空間溢出, 我們不斷生成類往元空間灌, 類佔據的空間總是會超過 Metaspace 指定的空間大小的
*/
public class MetaspaceOOMTest {
static class OOMTest{
}
public static void main(String[] args) {
int i = 0; // 模擬計數多少次以後發生異常
try {
while (true) {
i++;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(OOMTest.class);
enhancer.setUseCache(false);
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
return methodProxy.invokeSuper(o, args);
}
});
enhancer.create();
}
} catch (Throwable e) {
System.out.println("***********多少次後發生了異常：" + i);
e.printStackTrace();
}
}
}
// java.lang.OutOfMemoryError: Metaspace