動手探究Java內存泄露問題

火星人 @ 2014-03-12 , reply:0


  

在本系列教程中,將帶大家動手探究Java內存泄露之謎,並教授給讀者相關的分析方法。以下是一個案例。

最近有一個伺服器,經常運行的時候就出現過載宕機的現象。重啟腳本和系統后,該個問題還是會出現。儘管有大量的數據丟失,但因不是關鍵業務,問題並 不嚴重。不過還是決定作進一步的調查,來看下問題到底出現在哪。首先注意到的是,伺服器通過了所有的單元測試和完整的集成環境的測試。在測試環境下使用測 試數據時運行正常,那麼為什麼在生產環境中運行會出現問題呢?很容易會想到,也許是因為實際運行時的負載大於測試時的負載,甚至超過了設計的負荷,從而耗 盡了資源。但是到底是什麼資源,在哪裡耗盡了呢?下面我們就研究這個問題

為了演示這個問題,首先要做的是編寫一些內存泄露的代碼,將使用生產-消費者模式去實現,以便更好說明問題。

例子中,假定有這樣一個場景:假設你為一個證?瘓?凸?竟ぷ鰨?飧齬?窘?善鋇南?鄱詈凸煞菁鍬莢謔?菘庵小Mü?桓黽虻ソ?袒袢∶?畈⒔?浯娣旁諞桓齠恿兄小A硪桓黿?檀癰枚恿兄卸寥∶?畈⒔?湫慈朧?菘狻C?畹?OJO對象十分簡單,如下代碼所示:
 

  1. public class Order { 
  2.   
  3.   private final int id; 
  4.   
  5.   private final String code; 
  6.   
  7.   private final int amount; 
  8.   
  9.   private final double price; 
  10.   
  11.   private final long time; 
  12.   
  13.   private final long[] padding; 
  14.   
  15.   /** 
  16.    * @param id 
  17.    *            The order id 
  18.    * @param code 
  19.    *            The stock code 
  20.    * @param amount 
  21.    *            the number of shares 
  22.    * @param price 
  23.    *            the price of the share 
  24.    * @param time 
  25.    *            the transaction time 
  26.    */ 
  27.   public Order(int id, String code, int amount, double price, long time) { 
  28.     super(); 
  29.     this.id = id; 
  30.     this.code = code; 
  31.     this.amount = amount; 
  32.     this.price = price; 
  33.     this.time = time; 
  34.     
  35.     //這裡故意設置Order對象足夠大,以方便例子稍後在運行的時候耗盡內存 
  36.     this.padding = new long[3000]; 
  37.     Arrays.fill(padding, 0, padding.length - 1, -2); 
  38.   } 
  39.   
  40.   public int getId() { 
  41.     return id; 
  42.   } 
  43.   
  44.   public String getCode() { 
  45.     return code; 
  46.   } 
  47.   
  48.   public int getAmount() { 
  49.     return amount; 
  50.   } 
  51.   
  52.   public double getPrice() { 
  53.     return price; 
  54.   } 
  55.   
  56.   public long getTime() { 
  57.     return time; 
  58.   } 
  59.   

這個POJO對象是Spring應用的一部分,該應用有三個主要的抽象類,當Spring調用它們的start()方法的時候將分別創建一個新的線程。

第一個抽象類是OrderFeed。run()方法將生成一系列隨機的Order對象,並將其放置在隊列中,然後它會睡眠一會兒,又再接著生成一個新的Order對象,代碼如下:

  1. public class OrderFeed implements Runnable { 
  2.  
  3.  private static Random rand = new Random(); 
  4.  
  5.  private static int id = 0
  6.  
  7.  private final BlockingQueue orderQueue; 
  8.  
  9.  public OrderFeed(BlockingQueue orderQueue) { 
  10.    this.orderQueue = orderQueue; 
  11.  } 
  12.  
  13.  /** 
  14.   *在載入Context上下文後由Spring調用,開始生產order對象 
  15.   */ 
  16.  public void start() { 
  17.  
  18.    Thread thread = new Thread(this"Order producer"); 
  19.    thread.start(); 
  20.  } 
  21.  
  22.   @Override 
  23.  public void run() { 
  24.  
  25.    while (true) { 
  26.      Order order = createOrder(); 
  27.      orderQueue.add(order); 
  28.      sleep(); 
  29.    } 
  30.  } 
  31.  
  32.  private Order createOrder() { 
  33.  
  34.    final String[] stocks = { "BLND.L""DGE.L""MKS.L""PSON.L""RIO.L""PRU.L"
  35.        "LSE.L""WMH.L" }; 
  36.    int next = rand.nextInt(stocks.length); 
  37.    long now = System.currentTimeMillis(); 
  38.  
  39.    Order order = new Order(++id, stocks[next], next * 100, next * 10, now); 
  40.    return order; 
  41.  } 
  42.  
  43.  private void sleep() { 
  44.    try { 
  45.      TimeUnit.MILLISECONDS.sleep(100); 
  46.    } catch (InterruptedException e) { 
  47.      e.printStackTrace(); 
  48.    } 
  49.  } 

第二個類是OrderRecord,這個類負責從隊列中提取Order對象,並將它們寫入資料庫。問題是,將Order對象寫入資料庫的耗時比產生Order對象的耗時要長得多。為了演示,將在recordOrder()方法中讓其睡眠1秒。

  1. public class OrderRecord implements Runnable { 
  2.  
  3.   private final BlockingQueue orderQueue; 
  4.  
  5.   public OrderRecord(BlockingQueue orderQueue) { 
  6.     this.orderQueue = orderQueue; 
  7.   } 
  8.  
  9.   public void start() { 
  10.  
  11.     Thread thread = new Thread(this"Order Recorder"); 
  12.     thread.start(); 
  13.   } 
  14.  
  15.   @Override 
  16.   public void run() { 
  17.  
  18.     while (true) { 
  19.  
  20.       try { 
  21.         Order order = orderQueue.take(); 
  22.         recordOrder(order); 
  23.       } catch (InterruptedException e) { 
  24.         e.printStackTrace(); 
  25.       } 
  26.     } 
  27.  
  28.   } 
  29.  
  30.   /** 
  31.    * 模擬記錄到資料庫的方法,這裡只是簡單讓其睡眠一秒  
  32.    */ 
  33.   public void recordOrder(Order order) throws InterruptedException { 
  34.     TimeUnit.SECONDS.sleep(1); 
  35.   } 
  36.  

為了證明這個效果,特意增加了一個監視類 OrderQueueMonitor ,這個類每隔幾秒就列印出隊列的大小,代碼如下:

  1. public class OrderQueueMonitor implements Runnable { 
  2.  
  3.   private final BlockingQueue orderQueue; 
  4.  
  5.   public OrderQueueMonitor(BlockingQueue orderQueue) { 
  6.     this.orderQueue = orderQueue; 
  7.   } 
  8.  
  9.   public void start() { 
  10.  
  11.     Thread thread = new Thread(this"Order Queue Monitor"); 
  12.     thread.start(); 
  13.   } 
  14.  
  15.   @Override 
  16.   public void run() { 
  17.  
  18.     while (true) { 
  19.  
  20.       try { 
  21.         TimeUnit.SECONDS.sleep(2); 
  22.         int size = orderQueue.size(); 
  23.         System.out.println("Queue size is:" + size); 
  24.       } catch (InterruptedException e) { 
  25.         e.printStackTrace(); 
  26.       } 
  27.     } 
  28.   } 
  29.  

接下來配置Spring框架的相關配置文件如下:

  1. "1.0" encoding="UTF-8"?> 
  2. <beans xmlns="http://www.springframework.org/schema/beans" 
  3. xmlns:p="http://www.springframework.org/schema/p" 
  4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  5. xmlns:context="http://www.springframework.org/schema/context" 
  6. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
  7. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd" 
  8. default-init-method="start" 
  9. default-destroy-method="destroy"
  10.   
  11. <bean id="theQueue" class="java.util.concurrent.LinkedBlockingQueue"/>  
  12. <bean id="orderProducer"
  13. <constructor-arg ref="theQueue"/> 
  14.  
  15.   
  16. <bean id="OrderRecorder"
  17. <constructor-arg ref="theQueue"/> 
  18.  
  19.   
  20. <bean id="QueueMonitor"
  21. <constructor-arg ref="theQueue"/> 
  22.  
  23.   
  24.  

接下來運行這個Spring應用,並且可以通過jConsole去監控應用的內存情況,這需要作一些配置,配置如下:

  1. -Dcom.sun.management.jmxremote  
  2. -Dcom.sun.management.jmxremote.port=9010  
  3. -Dcom.sun.management.jmxremote.local.only=false  
  4. -Dcom.sun.management.jmxremote.authenticate=false  
  5. -Dcom.sun.management.jmxremote.ssl=false 

如果你看看堆的使用量,你會發現隨著隊列的增大,堆的使用量逐漸增大,如下圖所示,你可能不會發現1KB的內存泄露,但當達到1GB的內存溢出就很明顯了。所以,接下來要做的事情就是等待其溢出,然後進行分析。


接下來我們來看下如何發現並解決這類問題。在Java中,可以藉助不少自帶的或第三方的工具幫助我們進行相關的分析。

下面介紹分析程序內存泄露問題的三個步驟:

  1. 提取發生內存泄露的伺服器的轉儲文件。
  2. 用這個轉儲文件生成報告。
  3. 分析生成的報告。

有幾個工具能幫你生成堆轉儲文件,分別是:

  • jconsole
  •  visualvm
  • Eclipse Memory Analyser Tool(MAT)

用jconsole提取堆轉儲文件

使用jconsole連接到你的應用:單擊MBeans選項卡打開com.sun.management包,點擊 HotSpotDiagnostic,點擊Operations,然後選擇dumpHeap。這時你將會看到dumpHeap操作:它接受兩個參數p0和 p1。在p0的編輯框內輸入一個堆轉儲的文件名,然後按下DumpHeap按鈕就可以了。如下圖:


用jvisualvm提取堆轉儲文件

首先使用jvisual vm連接示例代碼,然後右鍵點擊應用,在左側的“application”窗格中選擇“Heap Dump”。

注意:如果需要分析的發生內存泄露的是在遠程伺服器上,那麼jvisualvm將會把轉存出來的文件保存在遠程機器(假設這是一台unix機器)上的/tmp目錄下。


用MAT來提取堆轉儲文件

jconsole和jvisualvm本身就是JDK的一部分,而MAT或被稱作“內存分析工具”,是一個基於eclipse的插件,可以從eclipse.org下載。

最新版本的MAT需要你在電腦上安裝JDk1.6。如果你用的是Java1.7版本也不用擔心,因為它會自動為你安裝1.6版本,並且不會和安裝好的1.7版本產生衝突。


使用MAT的時候,只需要點擊“Aquire Heap Dump”,然後按步驟操作就可以了,如下圖:

要注意的是,使用上面的三種方法,都需要配置遠程JMX連接如下:

  1. -Dcom.sun.management.jmxremote 
  2. -Dcom.sun.management.jmxremote.port=9010 
  3. -Dcom.sun.management.jmxremote.local.only=false 
  4. -Dcom.sun.management.jmxremote.authenticate=false 
  5. -Dcom.sun.management.jmxremote.ssl=false 

何時提取堆轉存文件

那麼在什麼時候才應該提取堆轉存文件呢?這需要耗費點心思和碰下運氣。如果過早提取了堆轉儲文件,那麼將可能不能發現問題癥結所在,因為它們被合法,非泄露類的實例屏蔽了。不過也不能等太久,因為提取堆轉儲文件也需要佔用內存,進行提取的時候可能會導致應用崩潰。

最好的辦法是將jconsole連接到應用程序並監控堆的佔用情況,知道它何時在崩潰的邊緣。因為沒有發生內存泄露時,三個堆部分指標都是綠色的,這樣很容易就能監控到。


分析轉儲文件

現在輪到MAT派上用場了,因為它本身就是設計用來分析堆轉儲文件的。要打開和分析一個堆轉儲文件,可以選擇File菜單的Heap Dump選項。選擇了要打開的文件后,將會看到如下三個選項:


選擇Leak Suspect Report選項。在MAT運行幾秒后,會生成如下圖的頁面:


如餅狀圖顯示:疑似有一處發生了內存泄露。也許你會想,這樣的做法只有在代碼受到控制的情況下才可取。畢竟這只是個例子,這又能說明什麼呢?好吧, 在這個例子里,所有的問題都是淺然易見的;線程a佔用了98.7MB內存,其他線程用了1.5MB。在實際情況中,得到的圖表可能是上圖那樣。讓我們繼續 探究,會得到如下圖:


如上圖所示,報告的下一部分告訴我們,有一個LinkedBlockQueue佔用了98.46%的內存。想要進一步的探究,點擊Details>>就可以了,如下圖:

可以看到,問題確實是出在我們的orderQueue上。這個隊列里存儲了所有生成的隨機生成的Order對象,並且可以被我們上篇博文里提到的三個線程OrderFeed、OrderRecord、OrderMonitor訪問。

那麼一切都清楚了,MAT告訴我們:示例代碼中有一個LinkedBlockQueue,這個隊列用盡了所有的內存,從而導致了嚴重的問題。不過我們不知道這個問題為什麼會產生,也不能指望MAT告訴我們。

本文代碼可以在:https://github.com/roghughe/captaindebug/tree/master/producer-consumer中下載。

原文鏈接:http://www.javacodegeeks.com/2013/12/investigating-memory-leaks-part-1-writing-leaky-code.html





[火星人 via ] 動手探究Java內存泄露問題已經有121次圍觀

http://www.coctec.com/docs/program/show-post-71268.html