快速定位Java 內存OOM的問題

Java服務出現瞭OOM(Out Of Memory)問題,總結瞭一些相對通用的方案,希望能幫助到Java技術棧的同學。

某Java服務(假設PID=10765)出現瞭OOM,最常見的原因為:

有可能是內存分配確實過小,而正常業務使用瞭大量內存

某一個對象被頻繁申請,卻沒有釋放,內存不斷泄漏,導致內存耗盡

某一個資源被頻繁申請,系統資源耗盡,例如:不斷創建線程,不斷發起網絡連接

畫外音:無非“本身資源不夠”“申請資源太多”“資源耗盡”幾個原因。

更具體的,可以使用以下工具逐一排查。

一、確認是不是內存本身就分配過小

方法:jmap -heap 10765

如上圖,可以查看新生代,老生代堆內存的分配大小以及使用情況,看是否本身分配過小。

二、找到最耗內存的對象

方法:jmap -histo:live 10765 | more

如上圖,輸入命令後,會以表格的形式顯示存活對象的信息,並按照所占內存大小排序:

實例數

所占內存大小

類名

是不是很直觀?對於實例數較多,占用內存大小較多的實例/類,相關的代碼就要針對性review瞭。

上圖中占內存最多的對象是RingBufferLogEvent,共占用內存18M,屬於正常使用范圍。

如果發現某類對象占用內存很大(例如幾個G),很可能是類對象創建太多,且一直未釋放。例如:

申請完資源後,未調用close()或dispose()釋放資源

消費者消費速度慢(或停止消費瞭),而生產者不斷往隊列中投遞任務,導致隊列中任務累積過多

畫外音:線上執行該命令會強制執行一次fgc。另外還可以dump內存進行分析。

三、確認是否是資源耗盡

工具:

pstree

netstat

查看進程創建的線程數,以及網絡連接數,如果資源耗盡,也可能出現OOM。

這裡介紹另一種方法,通過

/proc/${PID}/fd

/proc/${PID}/task

可以分別查看句柄詳情和線程數。

例如,某一臺線上服務器的sshd進程PID是9339,查看

ll /proc/9339/fd

ll /proc/9339/task

如上圖,sshd共占用瞭四個句柄

0 -> 標準輸入

1 -> 標準輸出

2 -> 標準錯誤輸出

3 -> socket(容易想到是監聽端口)

sshd隻有一個主線程PID為9339,並沒有多線程。

所以,隻要

ll /proc/${PID}/fd | wc -l

ll /proc/${PID}/task | wc -l (效果等同pstree -p | wc -l)

就能知道進程打開的句柄數和線程數。

補充:Java內存溢出OOM

Java內存溢出OOM

經典錯誤

JVM中常見的兩個錯誤

StackoverFlowError :棧溢出

OutofMemoryError: java heap space:堆溢出

除此之外,還有以下的錯誤

java.lang.StackOverflowError
java.lang.OutOfMemoryError:java heap space
java.lang.OutOfMemoryError:GC overhead limit exceeeded
java.lang.OutOfMemoryError:Direct buffer memory
java.lang.OutOfMemoryError:unable to create new native thread
java.lang.OutOfMemoryError:Metaspace

架構

OutOfMemoryError和StackOverflowError是屬於Error,不是Exception

StackoverFlowError

堆棧溢出,我們有最簡單的一個遞歸調用,就會造成堆棧溢出,也就是深度的方法調用

棧一般是512K,不斷的深度調用,直到棧被撐破

public class StackOverflowErrorDemo {
  public static void main(String[] args) {
    stackOverflowError();
  }
  /**
   * 棧一般是512K,不斷的深度調用,直到棧被撐破
   * Exception in thread "main" java.lang.StackOverflowError
   */
  private static void stackOverflowError() {
    stackOverflowError();
  }
}

運行結果

Exception in thread "main" java.lang.StackOverflowError
  at com.moxi.interview.study.oom.StackOverflowErrorDemo.stackOverflowError(StackOverflowErrorDemo.java:17)

OutOfMemoryError

java heap space

創建瞭很多對象,導致堆空間不夠存儲

/**
 * Java堆內存不足
 */
public class JavaHeapSpaceDemo {
  public static void main(String[] args) {
    // 堆空間的大小 -Xms10m -Xmx10m
    // 創建一個 80M的字節數組
    byte [] bytes = new byte[80 * 1024 * 1024];
  }
}

我們創建一個80M的數組,會直接出現Java heap space

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

GC overhead limit exceeded

GC回收時間過長時會拋出OutOfMemoryError,過長的定義是,超過瞭98%的時間用來做GC,並且回收瞭不到2%的堆內存

連續多次GC都隻回收瞭不到2%的極端情況下,才會拋出。假設不拋出GC overhead limit 錯誤會造成什麼情況呢?

那就是GC清理的這點內存很快會再次被填滿,迫使GC再次執行,這樣就形成瞭惡性循環,CPU的使用率一直都是100%,而GC卻沒有任何成果。

代碼演示:

為瞭更快的達到效果,我們首先需要設置JVM啟動參數

-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:MaxDirectMemorySize=5m

這個異常出現的步驟就是,我們不斷的像list中插入String對象,直到啟動GC回收

/**
 * GC 回收超時
 * JVM參數配置: -Xms10m -Xmx10m -XX:+PrintGCDetails
 */
public class GCOverheadLimitDemo {
  public static void main(String[] args) {
    int i = 0;
    List<String> list = new ArrayList<>();
    try {
      while(true) {
        //1.6時intern()方法發現字符串常量池(存儲永久代)沒有就復制,物理拷貝
        //1.7時intern()方法發現字符串常量池(存儲堆)沒有就在保存地址值映射實際堆內存對象
        list.add(String.valueOf(++i).intern());
      }
    } catch (Exception e) {
      System.out.println("***************i:" + i);
      e.printStackTrace();
      throw e;
    } finally {
    }
  }
}

運行結果

[Full GC (Ergonomics) [PSYoungGen: 2047K->2047K(2560K)] [ParOldGen: 7106K->7106K(7168K)] 9154K->9154K(9728K), [Metaspace: 3504K->3504K(1056768K)], 0.0311093 secs] [Times: user=0.13 sys=0.00, real=0.03 secs] 
[Full GC (Ergonomics) [PSYoungGen: 2047K->0K(2560K)] [ParOldGen: 7136K->667K(7168K)] 9184K->667K(9728K), [Metaspace: 3540K->3540K(1056768K)], 0.0058093 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
Heap
 PSYoungGen   total 2560K, used 114K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
 eden space 2048K, 5% used [0x00000000ffd00000,0x00000000ffd1c878,0x00000000fff00000)
 from space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
 to  space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
 ParOldGen    total 7168K, used 667K [0x00000000ff600000, 0x00000000ffd00000, 0x00000000ffd00000)
 object space 7168K, 9% used [0x00000000ff600000,0x00000000ff6a6ff8,0x00000000ffd00000)
 Metaspace    used 3605K, capacity 4540K, committed 4864K, reserved 1056768K
 class space  used 399K, capacity 428K, committed 512K, reserved 1048576K
Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
  at java.lang.Integer.toString(Integer.java:403)
  at java.lang.String.valueOf(String.java:3099)
  at com.moxi.interview.study.oom.GCOverheadLimitDemo.main(GCOverheadLimitDemo.java:18)

我們能夠看到 多次Full GC,並沒有清理出空間,在多次執行GC操作後,就拋出異常 GC overhead limit

Direct buffer memory

Netty + NIO:這是由於NIO引起的

寫NIO程序的時候經常會使用ByteBuffer來讀取或寫入數據,這是一種基於通道(Channel) 與 緩沖區(Buffer)的I/O方式,它可以使用Native 函數庫直接分配堆外內存,然後通過一個存儲在Java堆裡面的DirectByteBuffer對象作為這塊內存的引用進行操作。這樣能在一些場景中顯著提高性能,因為避免瞭在Java堆和Native堆中來回復制數據。

ByteBuffer.allocate(capability):第一種方式是分配JVM堆內存,屬於GC管轄范圍,由於需要拷貝所以速度相對較慢

ByteBuffer.allocteDirect(capability):第二種方式是分配OS本地內存,不屬於GC管轄范圍,由於不需要內存的拷貝,所以速度相對較快

但如果不斷分配本地內存,堆內存很少使用,那麼JVM就不需要執行GC,DirectByteBuffer對象就不會被回收,這時候堆內存充足,但本地內存可能已經使用光瞭,再次嘗試分配本地內存就會出現OutOfMemoryError,那麼程序就崩潰瞭。

一句話說:本地內存不足,但是堆內存充足的時候,就會出現這個問題

我們使用 -XX:MaxDirectMemorySize=5m 配置能使用的堆外物理內存為5M

-Xms20m -Xmx20m -XX:+PrintGCDetails -XX:MaxDirectMemorySize=5m

然後我們申請一個6M的空間

// 隻設置瞭5M的物理內存使用,但是卻分配 6M的空間
ByteBuffer bb = ByteBuffer.allocateDirect(6 * 1024 * 1024);

這個時候,運行就會出現問題瞭

配置的maxDirectMemory:5.0MB

[GC (System.gc()) [PSYoungGen: 2030K->488K(2560K)] 2030K->796K(9728K), 0.0008326 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (System.gc()) [PSYoungGen: 488K->0K(2560K)] [ParOldGen: 308K->712K(7168K)] 796K->712K(9728K), [Metaspace: 3512K->3512K(1056768K)], 0.0052052 secs] [Times: user=0.09 sys=0.00, real=0.00 secs] 
Exception in thread "main" java.lang.OutOfMemoryError: Direct buffer memory
  at java.nio.Bits.reserveMemory(Bits.java:693)
  at java.nio.DirectByteBuffer.<init>(DirectByteBuffer.java:123)
  at java.nio.ByteBuffer.allocateDirect(ByteBuffer.java:311)
  at com.moxi.interview.study.oom.DIrectBufferMemoryDemo.main(DIrectBufferMemoryDemo.java:19)

unable to create new native thread

不能夠創建更多的新的線程瞭,也就是說創建線程的上限達到瞭

在高並發場景的時候,會應用到

高並發請求服務器時,經常會出現如下異常java.lang.OutOfMemoryError:unable to create new native thread,準確說該native thread異常與對應的平臺有關

導致原因:

應用創建瞭太多線程,一個應用進程創建多個線程,超過系統承載極限

服務器並不允許你的應用程序創建這麼多線程,linux系統默認運行單個進程可以創建的線程為1024個,如果應用創建超過這個數量,就會報 java.lang.OutOfMemoryError:unable to create new native thread

解決方法:

想辦法降低你應用程序創建線程的數量,分析應用是否真的需要創建這麼多線程,如果不是,改代碼將線程數降到最低

對於有的應用,確實需要創建很多線程,遠超過linux系統默認1024個線程限制,可以通過修改linux服務器配置,擴大linux默認限制

/**
 * 無法創建更多的線程
 */
public class UnableCreateNewThreadDemo {
  public static void main(String[] args) {
    for (int i = 0; ; i++) {
      System.out.println("************** i = " + i);
      new Thread(() -> {
        try {
          TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }, String.valueOf(i)).start();
    }
  }
}

這個時候,就會出現下列的錯誤,線程數大概在 900多個

Exception in thread "main" java.lang.OutOfMemoryError: unable to cerate new native thread

如何查看線程數

ulimit -u

Metaspace

元空間內存不足,Matespace元空間應用的是本地內存

-XX:MetaspaceSize 的初始化大小為20M

元空間是什麼

元空間就是我們的方法區,存放的是類模板,類信息,常量池等

Metaspace是方法區HotSpot中的實現,它與持久代最大的區別在於:Metaspace並不在虛擬內存中,而是使用本地內存,也即在java8中,class metadata(the virtual machines internal presentation of Java class),被存儲在叫做Matespace的native memory

永久代(java8後背元空間Metaspace取代瞭)存放瞭以下信息:

虛擬機加載的類信息

常量池

靜態變量

即時編譯後的代碼

模擬Metaspace空間溢出,我們不斷生成類 往元空間裡灌輸,類占據的空間總會超過Metaspace指定的空間大小

代碼

在模擬異常生成時候,因為初始化的元空間為20M,因此我們使用JVM參數調整元空間的大小,為瞭更好的效果

-XX:MetaspaceSize=8m -XX:MaxMetaspaceSize=8m

代碼如下:

/**
 * 元空間溢出
 *
 */
public class MetaspaceOutOfMemoryDemo {
  // 靜態類
  static class OOMTest {
  }
  public static void main(final String[] args) {
    // 模擬計數多少次以後發生異常
    int i =0;
    try {
      while (true) {
        i++;
        // 使用Spring的動態字節碼技術
        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);
          }
        });
      }
    } catch (Exception e) {
      System.out.println("發生異常的次數:" + i);
      e.printStackTrace();
    } finally {
    }
  }
}

會出現以下錯誤:

發生異常的次數: 201

java.lang.OutOfMemoryError:Metaspace

註意

在JDK1.7之前:永久代是方法區的實現,存放瞭運行時常量池、字符串常量池和靜態變量等。

在JDK1.7:永久代是方法區的實現,將字符串常量池和靜態變量等移出至堆內存。運行時常量池等剩下的還再永久代(方法區)

在JDK1.8及以後:永久代被元空間替代,相當於元空間實現方法區,此時字符串常量池和靜態變量還在堆,運行時常量池還在方法區(元空間),元空間使用的是直接內存。

-XX:MetaspaceSize=N//設置Metaspace的初始(和最小大小) -XX:MaxMetaspaceSize=N//設置Metaspace的最大大小 與永久代很大的不同就是,如果不指定大小的話,隨著更多類的創建,虛擬機會耗盡所有可用的系統內存。

以上為個人經驗,希望能給大傢一個參考,也希望大傢多多支持WalkonNet。如有錯誤或未考慮完全的地方,望不吝賜教。

推薦閱讀: