日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產(chǎn)品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
動手探究Java內存泄露問題

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

成都創(chuàng)新互聯(lián)專注于廣元網(wǎng)站建設服務及定制，我們擁有豐富的企業(yè)做網(wǎng)站經(jīng)驗。 熱誠為您提供廣元營銷型網(wǎng)站建設，廣元網(wǎng)站制作、廣元網(wǎng)頁設計、廣元網(wǎng)站官網(wǎng)定制、小程序制作服務，打造廣元網(wǎng)絡公司原創(chuàng)品牌,更為您提供廣元網(wǎng)站排名全網(wǎng)營銷落地服務。

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

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

例子中，假定有這樣一個場景：假設你為一個證劵經(jīng)紀公司工作，這個公司將股票的銷售額和股份記錄在數(shù)據(jù)庫中。通過一個簡單進程獲取命令并將其存放在一個隊列中。另一個進程從該隊列中讀取命令并將其寫入數(shù)據(jù)庫。命令的POJO對象十分簡單，如下代碼所示：
 

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

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

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

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

#p#

第二個類是OrderRecord，這個類負責從隊列中提取Order對象，并將它們寫入數(shù)據(jù)庫。問題是，將Order對象寫入數(shù)據(jù)庫的耗時比產(chǎn)生Order對象的耗時要長得多。為了演示，將在recordOrder()方法中讓其睡眠1秒。

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

為了證明這個效果，特意增加了一個監(jiān)視類 OrderQueueMonitor ，這個類每隔幾秒就打印出隊列的大小，代碼如下：

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

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

 
 
 
 
    
  
  
  
  
  1.  
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. xmlns:p="http://www.springframework.org/schema/p" 
    4. 
  
  
  
  
  4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    5. 
  
  
  
  
  5. xmlns:context="http://www.springframework.org/schema/context" 
    6. 
  
  
  
  
  6. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
    7. 
  
  
  
  
  7. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd" 
    8. 
  
  
  
  
  8. default-init-method="start" 
    9. 
  
  
  
  
  9. default-destroy-method="destroy"> 
    10. 
  
  
  
  
  10.   
    11. 
  
  
  
  
  11.   
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15.   
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19.   
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23.   
    24. 
  
  
  
  
  24.  
    25.

接下來運行這個Spring應用，并且可以通過jConsole去監(jiān)控應用的內存情況，這需要作一些配置，配置如下：

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

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

#p#

接下來我們來看下如何發(fā)現(xiàn)并解決這類問題。在Java中，可以借助不少自帶的或第三方的工具幫助我們進行相關的分析。

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

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

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

  • jconsole
  •  visualvm
  • Eclipse Memory Analyser Tool（MAT）

用jconsole提取堆轉儲文件

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

用jvisualvm提取堆轉儲文件

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

注意：如果需要分析的發(fā)生內存泄露的是在遠程服務器上，那么jvisualvm將會把轉存出來的文件保存在遠程機器（假設這是一臺unix機器）上的/tmp目錄下。

用MAT來提取堆轉儲文件

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

最新版本的MAT需要你在電腦上安裝JDk1.6。如果你用的是Java1.7版本也不用擔心，因為它會自動為你安裝1.6版本，并且不會和安裝好的1.7版本產(chǎn)生沖突。

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

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

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

何時提取堆轉存文件

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

最好的辦法是將jconsole連接到應用程序并監(jiān)控堆的占用情況，知道它何時在崩潰的邊緣。因為沒有發(fā)生內存泄露時，三個堆部分指標都是綠色的，這樣很容易就能監(jiān)控到，如下圖：

分析轉儲文件

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

#p#

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

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

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

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

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

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


新聞標題：動手探究Java內存泄露問題
標題鏈接：http://www.5511xx.com/article/dhhcoip.html