java內存泄露分析方案,內存泄露Java

本文目錄一覽：

• 1、請教java堆外內存泄漏分析定位方法
• 2、java內存泄漏怎麼解決
• 3、如何排查Java內存泄露
• 4、常見的內存泄漏原因及解決方法
• 5、java中內存泄露有幾種？如何分析泄露原因

請教java堆外內存泄漏分析定位方法

4.Java中參數都是傳值的。

對於基本類型，大家基本上沒有異議，但是對於引用類型我們也不能有異議。

Java內存泄露情況

JVM回收演算法 是很複雜的，我也不知道他們怎麼實現的，但是我只知道他們要實現的就是：對於沒有被引用的對象是可以回收的。所以你要造成內存泄露就要做到：

持有對無用對象的引用!

不要以為這個很輕易做到，既然無用，你怎麼還會持有它的引用? 既然你還持有它，它怎麼會是無用的呢?

以下以堆棧更經典這個經典的例子來剖析。

Java代碼

public class Stack {

private Object[] elements=new Object[10];

private int size = 0;

public void push(Object e){

ensureCapacity();

elements[size++] = e;

}

public Object pop(){

if( size == 0)

throw new EmptyStackException();

return elements[–size];

}

private void ensureCapacity(){

if(elements.length == size){

Object[] oldElements = elements;

elements = new Object[2 * elements.length+1];

System.arraycopy(oldElements,0, elements, 0, size);

}

}

}

上面的原理應該很簡單，假如堆棧加了10個元素，然後全部彈出來，雖然堆棧是空的，沒有我們要的東西，但是這是個對象是無法回收的，這個才符合了內存泄露的兩個條件：無用，無法回收。

但是就是存在這樣的東西也不一定會導致什麼樣的後果，假如這個堆棧用的比較少，也就浪費了幾個K內存而已，反正我們的內存都上G了，哪裡會有什麼影響，再說這個東西很快就會被回收的，有什麼關係。下面看兩個例子。

例子1

Java代碼

public class Bad{

public static Stack s=Stack();

static{

s.push(new Object());

s.pop(); //這裡有一個對象發生內存泄露

s.push(new Object()); //上面的對象可以被回收了，等於是自愈了

}

}

因為是static，就一直存在到程序退出，但是我們也可以看到它有自愈功能 ，就是說假如你的Stack最多有100個對象，那麼最多也就只有100個對象無法被回收其實這個應該很輕易理解，Stack內部持有100個引用，最壞的情況就是他們都是無用的，因為我們一旦放新的進取，以前的引用自然消失！

例子2

Java代碼

public class NotTooBad{

public void doSomething(){

Stack s=new Stack();

s.push(new Object());

//other code

s.pop();//這裡同樣導致對象無法回收,內存泄露.

}//退出方法,s自動無效,s可以被回收,Stack內部的引用自然沒了,所以

//這裡也可以自愈,而且可以說這個方法不存在內存泄露問題,不過是晚一點

//交給GC而已,因為它是封閉的,對外不開放,可以說上面的代碼99.9999%的

//情況是不會造成任何影響的,當然你寫這樣的代碼不會有什麼壞的影響,但是

//絕對可以說是垃圾代碼!沒有矛盾吧,我在裡面加一個空的for循環也不會有

//什麼太大的影響吧,你會這麼做嗎?

}

java內存泄漏怎麼解決

一般情況下內存泄漏的避免

在不涉及複雜數據結構的一般情況下，Java 的內存泄露表現為一個內存對象的生命周期超出了程序需要它的時間長度。我們有時也將其稱為「對象遊離」。

例如：

public class FileSearch{ private byte [] content; private File mFile; public FileSearch(File file){ mFile = file; } public boolean hasString(String str){ int size = getFileSize(mFile); content = new byte [size]; loadFile(mFile, content); String s = new String(content); return s.contains(str); }}

在這段代碼中，FileSearch 類中有一個函數 hasString ，用來判斷文檔中是否含有指定的字元串。流程是先將mFile 載入到內存中，然後進行判斷。但是，這裡的問題是，將 content 聲明為了實例變數，而不是本地變數。於是，在此函數返回之後，內存中仍然存在整個文件的數據。而很明顯，這些數據我們後續是不再需要的，這就造成了內存的無故浪費。

要避免這種情況下的內存泄露，要求我們以C/C++ 的內存管理思維來管理自己分配的內存。第一，是在聲明對象引用之前，明確內存對象的有效作用域。在一個函數內有效的內存對象，應該聲明為 local 變數，與類實例生命周期相同的要聲明為實例變數……以此類推。第二，在內存對象不再需要時，記得手動將其引用置空。

複雜數據結構中的內存泄露問題

在實際的項目中，我們經常用到一些較為複雜的數據結構用於緩存程序運行過程中需要的數據信息。有時，由於數據結構過於複雜，或者我們存在一些特殊的需求（例如，在內存允許的情況下，儘可能多的緩存信息來提高程序的運行速度等情況），我們很難對數據結構中數據的生命周期作出明確的界定。這個時候，我們可以使用Java 中一種特殊的機制來達到防止內存泄露的目的。

之前我們介紹過，Java 的 GC 機制是建立在跟蹤內存的引用機制上的。而在此之前，我們所使用的引用都只是定義一個「 Object o; 」這樣形式的。事實上，這只是 Java 引用機制中的一種默認情況，除此之外，還有其他的一些引用方式。通過使用這些特殊的引用機制，配合 GC 機制，就可以達到一些我們需要的效果。

Java中的幾種引用方式

Java中有幾種不同的引用方式，它們分別是：強引用、軟引用、弱引用和虛引用。下面，我們首先詳細地了解下這幾種引用方式的意義。

強引用

在此之前我們介紹的內容中所使用的引用 都是強引用，這是使用最普遍的引用。如果一個對象具有強引用，那就類似於必不可少的生活用品，垃圾回收器絕不會回收它。當內存空 間不足，Java 虛擬機寧願拋出 OutOfMemoryError 錯誤，使程序異常終止，也不會靠隨意回收具有強引用的對象來解決內存不足問題。

軟引用（SoftReference ）

SoftReference 類的一個典型用途就是用於內存敏感的高速緩存。SoftReference 的原理是：在保持對對象的引用時保證在 JVM 報告內存不足情況之前將清除所有的軟引用。關鍵之處在於，垃圾收集器在運行時可能會（也可能不會）釋放軟可及對象。對象是否被釋放取決於垃圾收集器的演算法 以及垃圾收集器運行時可用的內存數量。

弱引用（WeakReference ）

WeakReference 類的一個典型用途就是規範化映射（ canonicalized mapping ）。另外，對於那些生存期相對較長而且重新創建的開銷也不高的對象來說，弱引用也比較有用。關鍵之處在於，垃圾收集器運行時如果碰到了弱可及對象，將釋放 WeakReference 引用的對象。然而，請注意，垃圾收集器可能要運行多次才能找到並釋放弱可及對象。

虛引用（PhantomReference ）

PhantomReference 類只能用於跟蹤對被引用對象即將進行的收集。同樣，它還能用於執行 pre-mortem 清除操作。PhantomReference 必須與 ReferenceQueue 類一起使用。需要 ReferenceQueue 是因為它能夠充當通知機制。當垃圾收集器確定了某個對象是虛可及對象時， PhantomReference 對象就被放在它的 ReferenceQueue 上。將 PhantomReference 對象放在 ReferenceQueue 上也就是一個通知，表明 PhantomReference 對象引用的對象已經結束，可供收集了。這使您能夠剛好在對象佔用的內存被回收之前採取行動。Reference與 ReferenceQueue 的配合使用。

GC、 Reference 與 ReferenceQueue 的交互

A、 GC無法刪除存在強引用的對象的內存。

B、 GC發現一個只有軟引用的對象內存，那麼：

① SoftReference對象的 referent 域被設置為 null ，從而使該對象不再引用 heap 對象。

② SoftReference引用過的 heap 對象被聲明為 finalizable 。

③ 當 heap 對象的 finalize() 方法被運行而且該對象佔用的內存被釋放， SoftReference 對象就被添加到它的 ReferenceQueue （如果後者存在的話）。

C、 GC發現一個只有弱引用的對象內存，那麼：

① WeakReference對象的 referent 域被設置為 null , 從而使該對象不再引用heap 對象。

② WeakReference引用過的 heap 對象被聲明為 finalizable 。

③ 當heap 對象的 finalize() 方法被運行而且該對象佔用的內存被釋放時， WeakReference 對象就被添加到它的 ReferenceQueue （如果後者存在的話）。

D、 GC發現一個只有虛引用的對象內存，那麼：

① PhantomReference引用過的 heap 對象被聲明為 finalizable 。

② PhantomReference在堆對象被釋放之前就被添加到它的 ReferenceQueue 。

值得注意的地方有以下幾點：

1、 GC 在一般情況下不會發現軟引用的內存對象，只有在內存明顯不足的時候才會發現並釋放軟引用對象的內存。

2、 GC 對弱引用的發現和釋放也不是立即的，有時需要重複幾次 GC ，才會發現並釋放弱引用的內存對象。3、軟引用和弱引用在添加到 ReferenceQueue 的時候，其指向真實內存的引用已經被置為空了，相關的內存也已經被釋放掉了。而虛引用在添加到 ReferenceQueue 的時候，內存還沒有釋放，仍然可以對其進行訪問。

代碼示例

通過以上的介紹，相信您對Java 的引用機制以及幾種引用方式的異同已經有了一定了解。光是概念，可能過於抽象，下面我們通過一個例子來演示如何在代碼中使用 Reference 機制。

String str = new String( ” hello ” ); // ①ReferenceQueue String rq = new ReferenceQueue String (); // ②WeakReference String wf = new WeakReference String (str, rq); // ③str = null ; // ④取消”hello”對象的強引用String str1 = wf.get(); // ⑤假如”hello”對象沒有被回收，str1引用”hello”對象// 假如”hello”對象沒有被回收，rq.poll()返回nullReference ? extends String ref = rq.poll(); // ⑥

在以上代碼中，注意⑤⑥兩處地方。假如「hello 」對象沒有被回收 wf.get() 將返回「 hello 」字元串對象， rq.poll() 返回 null ；而加入「 hello 」對象已經被回收了，那麼 wf.get() 返回 null ， rq.poll() 返回 Reference 對象，但是此 Reference 對象中已經沒有 str 對象的引用了 ( PhantomReference 則與WeakReference 、 SoftReference 不同 )。

引用機制與複雜數據結構的聯合應用

了解了GC 機制、引用機制，並配合上 ReferenceQueue ，我們就可以實現一些防止內存溢出的複雜數據類型。

例如，SoftReference 具有構建 Cache 系統的特質，因此我們可以結合哈希表實現一個簡單的緩存系統。這樣既能保證能夠儘可能多的緩存信息，又可以保證 Java 虛擬機不會因為內存泄露而拋出 OutOfMemoryError 。這種緩存機制特別適合於內存對象生命周期長，且生成內存對象的耗時比較長的情況，例如緩存列表封面圖片等。對於一些生命周期較長，但是生成內存對象開銷不大的情況，使用WeakReference 能夠達到更好的內存管理的效果。

附SoftHashmap 的源碼一份，相信看過之後，大家會對 Reference 機制的應用有更深入的理解。

如何排查Java內存泄露

1.打開/tomcat_home/bin/catalina.bat文件

2.加上：set JAVA_OPTS=%JAVA_OPTS% -server -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=D:\heapdump，這樣當內存溢出是就會在對應路徑下生成dump文件

運行程序打開jdk bin 文件夾下再帶的 jvisualvm.exe

選擇tomcat線程，打開實時監控頁面可以看到對應的堆棧線程和裝在類，內存的實時情況

運行程序打開jdk bin 文件夾下再帶的 jconsole.exe，可以概覽堆棧線程和裝在類，內存的全部運行時間情況

下載安裝mat，dump分析軟體，安裝後，點擊file open 導入dump文件

打開後，灰色區域為可能發生內存溢出的區域，下帶問題描述

選擇Histogram，點擊shallow列進行排序，找出實例最多的

右鍵實例最的選擇list objects-with incoming references，可在根據正則表達式輸入自己想查的類，搜索，後右鍵打開 path to gc root-exclude phantom/weak/soft etc. references 就可以查出 調用為回收的相關信息。

常見的內存泄漏原因及解決方法

（Memory Leak，內存泄漏）

當一個對象已經不需要再使用本該被回收時，另外一個正在使用的對象持有它的引用從而導致它不能被回收，這導致本該被回收的對象不能被回收而停留在堆內存中，這就產生了內存泄漏。

內存泄漏是造成應用程序OOM的主要原因之一。我們知道Android系統為每個應用程序分配的內存是有限的，而當一個應用中產生的內存泄漏比較多時，這就難免會導致應用所需要的內存超過系統分配的內存限額，這就造成了內存溢出從而導致應用Crash。

因為內存泄漏是在堆內存中，所以對我們來說並不是可見的。通常我們可以藉助MAT、LeakCanary等工具來檢測應用程序是否存在內存泄漏。

1、MAT是一款強大的內存分析工具，功能繁多而複雜。

2、LeakCanary則是由Square開源的一款輕量級的第三方內存泄漏檢測工具，當檢測到程序中產生內存泄漏時，它將以最直觀的方式告訴我們哪裡產生了內存泄漏和導致誰泄漏了而不能被回收。

由於單例的靜態特性使得其生命周期和應用的生命周期一樣長，如果一個對象已經不再需要使用了，而單例對象還持有該對象的引用，就會使得該對象不能被正常回收，從而導致了內存泄漏。

示例：防止單例導致內存泄漏的實例

這樣不管傳入什麼Context最終將使用Application的Context，而單例的生命周期和應用的一樣長，這樣就防止了內存泄漏。？？？

例如，有時候我們可能會在啟動頻繁的Activity中，為了避免重複創建相同的數據資源，可能會出現如下寫法：

這樣在Activity內部創建了一個非靜態內部類的單例，每次啟動Activity時都會使用該單例的數據。雖然這樣避免了資源的重複創建，但是這種寫法卻會造成內存泄漏。因為非靜態內部類默認會持有外部類的引用，而該非靜態內部類又創建了一個靜態的實例，該實例的生命周期和應用的一樣長，這就導致了該靜態實例一直會持有該Activity的引用，從而導致Activity的內存資源不能被正常回收。

解決方法 ：將該內部類設為靜態內部類或將該內部類抽取出來封裝成一個單例，如果需要使用Context，就使用Application的Context。

示例：創建匿名內部類的靜態對象

1、從Android的角度

當Android應用程序啟動時，該應用程序的主線程會自動創建一個Looper對象和與之關聯的MessageQueue。當主線程中實例化一個Handler對象後，它就會自動與主線程Looper的MessageQueue關聯起來。所有發送到MessageQueue的Messag都會持有Handler的引用，所以Looper會據此回調Handle的handleMessage()方法來處理消息。只要MessageQueue中有未處理的Message，Looper就會不斷的從中取出並交給Handler處理。另外，主線程的Looper對象會伴隨該應用程序的整個生命周期。

2、 Java角度

在Java中，非靜態內部類和匿名類內部類都會潛在持有它們所屬的外部類的引用，但是靜態內部類卻不會。

對上述的示例進行分析，當MainActivity結束時，未處理的消息持有handler的引用，而handler又持有它所屬的外部類也就是MainActivity的引用。這條引用關係會一直保持直到消息得到處理，這樣阻止了MainActivity被垃圾回收器回收，從而造成了內存泄漏。

解決方法 ：將Handler類獨立出來或者使用靜態內部類，這樣便可以避免內存泄漏。

示例：AsyncTask和Runnable

AsyncTask和Runnable都使用了匿名內部類，那麼它們將持有其所在Activity的隱式引用。如果任務在Activity銷毀之前還未完成，那麼將導致Activity的內存資源無法被回收，從而造成內存泄漏。

解決方法 ：將AsyncTask和Runnable類獨立出來或者使用靜態內部類，這樣便可以避免內存泄漏。

對於使用了BraodcastReceiver，ContentObserver，File，Cursor，Stream，Bitmap等資源，應該在Activity銷毀時及時關閉或者註銷，否則這些資源將不會被回收，從而造成內存泄漏。

1）比如在Activity中register了一個BraodcastReceiver，但在Activity結束後沒有unregister該BraodcastReceiver。

2）資源性對象比如Cursor，Stream、File文件等往往都用了一些緩衝，我們在不使用的時候，應該及時關閉它們，以便它們的緩衝及時回收內存。它們的緩衝不僅存在於 java虛擬機內，還存在於java虛擬機外。如果我們僅僅是把它的引用設置為null，而不關閉它們，往往會造成內存泄漏。

3）對於資源性對象在不使用的時候，應該調用它的close()函數將其關閉掉，然後再設置為null。在我們的程序退出時一定要確保我們的資源性對象已經關閉。

4）Bitmap對象不在使用時調用recycle()釋放內存。2.3以後的bitmap應該是不需要手動recycle了，內存已經在java層了。

初始時ListView會從BaseAdapter中根據當前的屏幕布局實例化一定數量的View對象，同時ListView會將這些View對象緩存起來。當向上滾動ListView時，原先位於最上面的Item的View對象會被回收，然後被用來構造新出現在下面的Item。這個構造過程就是由getView()方法完成的，getView()的第二個形參convertView就是被緩存起來的Item的View對象（初始化時緩存中沒有View對象則convertView是null）。

構造Adapter時，沒有使用緩存的convertView。

解決方法 ：在構造Adapter時，使用緩存的convertView。

我們通常把一些對象的引用加入到了集合容器（比如ArrayList）中，當我們不需要該對象時，並沒有把它的引用從集合中清理掉，這樣這個集合就會越來越大。如果這個集合是static的話，那情況就更嚴重了。

解決方法 ：在退出程序之前，將集合里的東西clear，然後置為null，再退出程序。

當我們不要使用WebView對象時，應該調用它的destory()函數來銷毀它，並釋放其佔用的內存，否則其長期佔用的內存也不能被回收，從而造成內存泄露。

解決方法 ：為WebView另外開啟一個進程，通過AIDL與主線程進行通信，WebView所在的進程可以根據業務的需要選擇合適的時機進行銷毀，從而達到內存的完整釋放。

1、在涉及使用Context時，對於生命周期比Activity長的對象應該使用Application的Context。凡是使用Context優先考慮Application的Context，當然它並不是萬能的，對於有些地方則必須使用Activity的Context。對於Application，Service，Activity三者的Context的應用場景如下：

其中，NO1表示Application和Service可以啟動一個Activity，不過需要創建一個新的task任務隊列。而對於Dialog而言，只有在Activity中才能創建。除此之外三者都可以使用。

2、對於需要在靜態內部類中使用非靜態外部成員變數（如：Context、View )，可以在靜態內部類中使用弱引用來引用外部類的變數來避免內存泄漏。

3、對於不再需要使用的對象，顯示的將其賦值為null，比如使用完Bitmap後先調用recycle()，再賦為null。

4、保持對對象生命周期的敏感，特別注意單例、靜態對象、全局性集合等的生命周期。

5、對於生命周期比Activity長的內部類對象，並且內部類中使用了外部類的成員變數，可以這樣做避免內存泄漏：

1）將內部類改為靜態內部類

2）靜態內部類中使用弱引用來引用外部類的成員變數

Android內存泄漏總結

java中內存泄露有幾種？如何分析泄露原因

一、Java內存回收機制

不論哪種語言的內存分配方式，都需要返回所分配內存的真實地址，也就是返回一個指針到內存塊的首地址。Java中對象是採用new或者反射的方法創建的，這些對象的創建都是在堆（Heap）中分配的，所有對象的回收都是由Java虛擬機通過垃圾回收機制完成的。GC為了能夠正確釋放對象，會監控每個對象的運行狀況，對他們的申請、引用、被引用、賦值等狀況進行監控，Java會使用有向圖的方法進行管理內存，實時監控對象是否可以達到，如果不可到達，則就將其回收，這樣也可以消除引用循環的問題。在Java語言中，判斷一個內存空間是否符合垃圾收集標準有兩個：一個是給對象賦予了空值null，以下再沒有調用過，另一個是給對象賦予了新值，這樣重新分配了內存空間。

二、Java內存泄露引起原因

首先，什麼是內存泄露？經常聽人談起內存泄露，但要問什麼是內存泄露，沒幾個說得清楚。內存泄露是指無用對象（不再使用的對象）持續佔有內存或無用對象的內存得不到及時釋放，從而造成的內存空間的浪費稱為內存泄露。內存泄露有時不嚴重且不易察覺，這樣開發者就不知道存在內存泄露，但有時也會很嚴重，會提示你Out of memory。

那麼，Java內存泄露根本原因是什麼呢？長生命周期的對象持有短生命周期對象的引用就很可能發生內存泄露，儘管短生命周期對象已經不再需要，但是因為長生命周期對象持有它的引用而導致不能被回收，這就是java中內存泄露的發生場景。具體主要有如下幾大類：

1、靜態集合類引起內存泄露：

像HashMap、Vector等的使用最容易出現內存泄露，這些靜態變數的生命周期和應用程序一致，他們所引用的所有的對象Object也不能被釋放，因為他們也將一直被Vector等引用著。

例:

Static Vector v = new Vector(10);

for (int i = 1; i100; i++)

{

Object o = new Object();

v.add(o);

o = null;

}//

在這個例子中，循環申請Object 對象，並將所申請的對象放入一個Vector 中，如果僅僅釋放引用本身（o=null），那麼Vector 仍然引用該對象，所以這個對象對GC 來說是不可回收的。因此，如果對象加入到Vector 後，還必須從Vector 中刪除，最簡單的方法就是將Vector對象設置為null。

2、當集合裡面的對象屬性被修改後，再調用remove（）方法時不起作用。

例：

public static void main(String[] args)

{

SetPerson set = new HashSetPerson();

Person p1 = new Person(“唐僧”,”pwd1″,25);

Person p2 = new Person(“孫悟空”,”pwd2″,26);

Person p3 = new Person(“豬八戒”,”pwd3″,27);

set.add(p1);

set.add(p2);

set.add(p3);

System.out.println(“總共有:”+set.size()+” 個元素!”); //結果：總共有:3 個元素!

p3.setAge(2); //修改p3的年齡,此時p3元素對應的hashcode值發生改變

set.remove(p3); //此時remove不掉，造成內存泄漏

set.add(p3); //重新添加，居然添加成功

System.out.println(“總共有:”+set.size()+” 個元素!”); //結果：總共有:4 個元素!

for (Person person : set)

{

System.out.println(person);

}

}

3、監聽器

在java 編程中，我們都需要和監聽器打交道，通常一個應用當中會用到很多監聽器，我們會調用一個控制項的諸如addXXXListener()等方法來增加監聽器，但往往在釋放對象的時候卻沒有記住去刪除這些監聽器，從而增加了內存泄漏的機會。

4、各種連接

比如資料庫連接（dataSourse.getConnection()），網路連接(socket)和io連接，除非其顯式的調用了其close（）方法將其連接關閉，否則是不會自動被GC 回收的。對於Resultset 和Statement 對象可以不進行顯式回收，但Connection 一定要顯式回收，因為Connection 在任何時候都無法自動回收，而Connection一旦回收，Resultset 和Statement 對象就會立即為NULL。但是如果使用連接池，情況就不一樣了，除了要顯式地關閉連接，還必須顯式地關閉Resultset Statement 對象（關閉其中一個，另外一個也會關閉），否則就會造成大量的Statement 對象無法釋放，從而引起內存泄漏。這種情況下一般都會在try裡面去的連接，在finally裡面釋放連接。

5、內部類和外部模塊等的引用

內部類的引用是比較容易遺忘的一種，而且一旦沒釋放可能導致一系列的後繼類對象沒有釋放。此外程序員還要小心外部模塊不經意的引用，例如程序員A 負責A 模塊，調用了B 模塊的一個方法如：

public void registerMsg(Object b);

這種調用就要非常小心了，傳入了一個對象，很可能模塊B就保持了對該對象的引用，這時候就需要注意模塊B 是否提供相應的操作去除引用。

6、單例模式

不正確使用單例模式是引起內存泄露的一個常見問題，單例對象在被初始化後將在JVM的整個生命周期中存在（以靜態變數的方式），如果單例對象持有外部對象的引用，那麼這個外部對象將不能被jvm正常回收，導致內存泄露，考慮下面的例子：

class A{

public A(){

B.getInstance().setA(this);

}

….

}

//B類採用單例模式

class B{

private A a;

private static B instance=new B();

public B(){}

public static B getInstance(){

return instance;

}

public void setA(A a){

this.a=a;

}

//getter…

}

顯然B採用singleton模式，它持有一個A對象的引用，而這個A類的對象將不能被回收。想像下如果A是個比較複雜的對象或者集合類型會發生什麼情況