java內存泄露原因

㈠ 什麼原因可導致java內存泄漏

Java內存泄露

一般來說內存泄漏有兩種情況。一種情況如在C/C++語言中的，在堆中的分配的內存，在沒有將其釋放掉的時候，就將所有能訪問這塊內存的方式都刪掉（如指針重新賦值）；另一種情況則是在內存對象明明已經不需要的時候，還仍然保留著這塊內存和它的訪問方式（引用）。第一種情況，在Java中已經由於垃圾回收機制的引入，得到了很好的解決。所以，Java中的內存泄漏，主要指的是第二種情況。
可能光說概念太抽象了，大家可以看一下這樣的例子：

1 Vector v=new Vector(10);
2 for (int i=1;i<100; i++){
3 Object o=new Object();
4 v.add(o);
5 o=null;
6 }

在這個例子中，代碼棧中存在Vector對象的引用v和Object對象的引用o。在For循環中，我們不斷的生成新的對象，然後將其添加到Vector對象中，之後將o引用置空。問題是當o引用被置空後，如果發生GC，我們創建的Object對象是否能夠被GC回收呢？答案是否定的。因為，GC在跟蹤代碼棧中的引用時，會發現v引用，而繼續往下跟蹤，就會發現v引用指向的內存空間中又存在指向Object對象的引用。也就是說盡管o引用已經被置空，但是Object對象仍然存在其他的引用，是可以被訪問到的，所以GC無法將其釋放掉。如果在此循環之後，Object對象對程序已經沒有任何作用，那麼我們就認為此Java程序發生了內存泄漏。
盡管對於C/C++中的內存泄露情況來說，Java內存泄露導致的破壞性小，除了少數情況會出現程序崩潰的情況外，大多數情況下程序仍然能正常運行。但是，在移動設備對於內存和CPU都有較嚴格的限制的情況下，Java的內存溢出會導致程序效率低下、佔用大量不需要的內存等問題。這將導致整個機器性能變差，嚴重的也會引起拋出OutOfMemoryError，導致程序崩潰。

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

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

1 public class FileSearch{
2
3 private byte[] content;
4 private File mFile;
5
6 public FileSearch(File file){
7 mFile = file;
8 }
9
10 public boolean hasString(String str){
11 int size = getFileSize(mFile);
12 content = new byte[size];
13 loadFile(mFile, content);
14
15 String s = new String(content);
16 return s.contains(str);
17 }
18 }

在這段代碼中，FileSearch類中有一個函數hasString，用來判斷文檔中是否含有指定的字元串。流程是先將mFile載入到內存中，然後進行判斷。但是，這里的問題是，將content聲明為了實例變數，而不是本地變數。於是，在此函數返回之後，內存中仍然存在整個文件的數據。而很明顯，這些數據我們後續是不再需要的，這就造成了內存的無故浪費。
要避免這種情況下的內存泄露，要求我們以C/C++的內存管理思維來管理自己分配的內存。第一，是在聲明對象引用之前，明確內存對象的有效作用域。在一個函數內有效的內存對象，應該聲明為local變數，與類實例生命周期相同的要聲明為實例變數……以此類推。第二，在內存對象不再需要時，記得手動將其引用置空。

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

在實際的項目中，我們經常用到一些較為復雜的數據結構用於緩存程序運行過程中需要的數據信息。有時，由於數據結構過於復雜，或者我們存在一些特殊的需求（例如，在內存允許的情況下，盡可能多的緩存信息來提高程序的運行速度等情況），我們很難對數據結構中數據的生命周期作出明確的界定。這個時候，我們可以使用Java中一種特殊的機制來達到防止內存泄露的目的。
之前我們介紹過，Java的GC機制是建立在跟蹤內存的引用機制上的。而在此之前，我們所使用的引用都只是定義一個「Object o;」這樣形式的。事實上，這只是Java引用機制中的一種默認情況，除此之外，還有其他的一些引用方式。通過使用這些特殊的引用機制，配合GC機制，就可以達到一些我們需要的效果。

㈡ java會內存泄露么

會的。
java中的內存泄露的情況：長生命周期的對象持有短生命周期對象的引用就很可能發生內存泄露，盡管短生命周期對象已經不再需要，但是因為長生命周期對象持有它的引用而導致不能被回收，這就是java中內存泄露的發生場景，通俗地說，就是程序員可能創建了一個對象，以後一直不再使用這個對象，這個對象卻一直被引用，即這個對象無用但是卻無法被垃圾回收器回收的，這就是java中可能出現內存泄露的情況，例如，緩存系統，我們載入了一個對象放在緩存中(例如放在一個全局map對象中)，然後一直不再使用它，這個對象一直被緩存引用，但卻不再被使用。
檢查java中的內存泄露，一定要讓程序將各種分支情況都完整執行到程序結束，然後看某個對象是否被使用過，如果沒有，則才能判定這個對象屬於內存泄露。

如果一個外部類的實例對象的方法返回了一個內部類的實例對象，這個內部類對象被長期引用了，即使那個外部類實例對象不再被使用，但由於內部類持久外部類的實例對象，這個外部類對象將不會被垃圾回收，這也會造成內存泄露。

㈢ 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; i<100; 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)
{
Set<Person> set = new HashSet<Person>();
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是個比較復雜的對象或者集合類型會發生什麼情況

㈣ 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; i<100; 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)
{
Set<Person> set = new HashSet<Person>();
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是個比較復雜的對象或者集合類型會發生什麼情況

㈤ java在什麼情況下會出現內存泄露

內存泄露就是指一個不再被程序使用的對象或變數一直被占據在內存中。java中的內存泄露的情況：
1.長生命周期的對象持有短生命周期對象的引用就很可能發生內存泄露，例如，緩存系統，我們載入了一個對象放在緩存中(例如放在一個全局map對象中)，然後一直不再使用它，這個對象一直被緩存引用，但卻不再被使用。
2.集合類，而如果集合類是全局性的變數（比如類中的靜態屬性，全局性的map等即有靜態引用或final一直指向它），那麼沒有相應的刪除機制，很可能導致集合所佔用的內存只增不減，因此提供這樣的刪除機制或者定期清除策略非常必要。
3.單例模式。不正確使用單例模式是引起內存泄露的一個常見問題，單例對象在被初始化後將在JVM的整個生命周期中存在（以靜態變數的方式），如果單例對象持有外部對象的引用，那麼這個外部對象將不能被jvm正常回收，導致內存泄露

㈥ 如何判斷內存泄漏

內存泄露是指使用內存完成後沒有釋放，內存增長並不能分辨增長出來的內存是進程真正要用的，還是進程泄露出來的。而CPU的佔用是瞬時的、確定的，不存在某個進程申請了CPU占著不用的情況。在穩定性測試（也叫持久測試或疲勞測試）中，需要觀察內存是否有泄露。然而使用內存的進程千千萬，整個伺服器的內存增長似乎也不能判斷某個進程的內存有泄露。因此在穩定性測試過程中往往需要全程關注指定進程的內存消耗，比如運行3天、7天。

查看內存使用情況的命令有ps、sar、svmon、vmstat等等，但本文並不從工具使用的角度來介紹，而是從性能測試中關注指標的角度來介紹。如果採用其他命令查看內存，需注意，相似的名字在不同命令當中的含義是不一樣的，一定要搞清楚這個欄位的真正含義。

例1：Virtual這個詞，有時候在內存裡面指Paging Space（換頁空間），有時指進程空間裡面佔用的所有分頁（包括物理內存和Paging Space中的分頁）。

例2：Nmon中的PgIn/PgOut、topas中的PageIn/PageOut是指對文件系統的換頁，而vmstat中的pi/po是對Paging Space的換頁，而topas P中進程的PAGE SPACE是指進程的Data Segment。

㈦ 內存為什麼會泄漏java,c++等等都存在這個問題，泄漏的根本原因是什麼

內存泄露的根本原因是，堆區由程序員自動申請（C語言的malloc，C++的new，java中的new）的內存，沒有及時釋放。
C++自動申請的堆區的內存一定要自己釋放，系統只會在進程退出的時候才會幫你釋放。如果進程是守護進程（啟動後一直存在），那麼這個內存泄露會一直存在。
java有自己的內存回收機制，所以程序員自己new的對象不需要自己釋放，你可以認為系統會自動釋放。但是回收工具畢竟不是萬能的。（我是研究C++的，對java了解沒有那麼深入，但是內存泄露的原因肯定是一致的）。

㈧ java程序內存溢出一般什麼原因

JVM內存設置小了 或者一次性讀的數據過大 例如list vertor

一、內存溢出類型

1、java.lang.OutOfMemoryError: PermGen space

JVM管理兩種類型的內存，堆和非堆。堆是給開發人員用的上面說的就是，是在JVM啟動時創建；非堆是留給JVM自己用的，用來存放類的信息的。它和堆不同，運行期內GC不會釋放空間。如果web
app用了大量的第三方jar或者應用有太多的class文件而恰好MaxPermSize設置較小，超出了也會導致這塊內存的佔用過多造成溢出，或者tomcat熱部署時侯不會清理前面載入的環境，只會將context更改為新部署的，非堆存的內容就會越來越多。

PermGen space的全稱是Permanent Generation
space,是指內存的永久保存區域，這塊內存主要是被JVM存放Class和Meta信息的,Class在被Loader時就會被放到PermGen
space中，它和存放類實例(Instance)的Heap區域不同,GC(Garbage Collection)不會在主程序運行期對PermGen
space進行清理，所以如果你的應用中有很CLASS的話,就很可能出現PermGen space錯誤，這種錯誤常見在web伺服器對JSP進行pre
compile的時候。如果你的WEB APP下都用了大量的第三方jar, 其大小超過了jvm默認的大小(4M)那麼就會產生此錯誤信息了。

一個最佳的配置例子：(經過本人驗證，自從用此配置之後，再未出現過tomcat死掉的情況)

set JAVA_OPTS=-Xms800m -Xmx800m -XX:PermSize=128M -XX:MaxNewSize=256m
-XX:MaxPermSize=256m

2、java.lang.OutOfMemoryError: Java heap space

第一種情況是個補充，主要存在問題就是出現在這個情況中。其默認空間(即-Xms)是物理內存的1/64，最大空間(-Xmx)是物理內存的1/4。如果內存剩餘不到40％，JVM就會增大堆到Xmx設置的值，內存剩餘超過70％，JVM就會減小堆到Xms設置的值。所以伺服器的Xmx和Xms設置一般應該設置相同避免每次GC後都要調整虛擬機堆的大小。假設物理內存無限大，那麼JVM內存的最大值跟操作系統有關，一般32位機是1.5g到3g之間，而64位的就不會有限制了。

注意：如果Xms超過了Xmx值，或者堆最大值和非堆最大值的總和超過了物理內存或者操作系統的最大限制都會引起伺服器啟動不起來。

垃圾回收GC的角色

JVM調用GC的頻度還是很高的，主要兩種情況下進行垃圾回收：

當應用程序線程空閑；另一個是java內存堆不足時，會不斷調用GC，若連續回收都解決不了內存堆不足的問題時，就會報out of
memory錯誤。因為這個異常根據系統運行環境決定，所以無法預期它何時出現。

根據GC的機制，程序的運行會引起系統運行環境的變化，增加GC的觸發機會。

為了避免這些問題，程序的設計和編寫就應避免垃圾對象的內存佔用和GC的開銷。顯示調用System.GC()只能建議JVM需要在內存中對垃圾對象進行回收，但不是必須馬上回收，

一個是並不能解決內存資源耗空的局面，另外也會增加GC的消耗。

二、JVM內存區域組成

簡單的說java中的堆和棧

java把內存分兩種：一種是棧內存，另一種是堆內存

1。在函數中定義的基本類型變數和對象的引用變數都在函數的棧內存中分配；

2。堆內存用來存放由new創建的對象和數組

在函數（代碼塊）中定義一個變數時，java就在棧中為這個變數分配內存空間，當超過變數的作用域後，java會自動釋放掉為該變數所分配的內存空間；在堆中分配的內存由java虛擬機的自動垃圾回收器來管理

堆的優勢是可以動態分配內存大小，生存期也不必事先告訴編譯器，因為它是在運行時動態分配內存的。缺點就是要在運行時動態分配內存，存取速度較慢；

棧的優勢是存取速度比堆要快，缺點是存在棧中的數據大小與生存期必須是確定的無靈活性。

java堆分為三個區：New、Old和Permanent

GC有兩個線程：

新創建的對象被分配到New區，當該區被填滿時會被GC輔助線程移到Old區，當Old區也填滿了會觸發GC主線程遍歷堆內存里的所有對象。Old區的大小等於Xmx減去-Xmn

java棧存放

棧調整：參數有+UseDefaultStackSize -Xss256K，表示每個線程可申請256k的棧空間

每個線程都有他自己的Stack

三、JVM如何設置虛擬內存

提示：在JVM中如果98％的時間是用於GC且可用的Heap size 不足2％的時候將拋出此異常信息。

提示：Heap Size 最大不要超過可用物理內存的80％，一般的要將-Xms和-Xmx選項設置為相同，而-Xmn為1/4的-Xmx值。

提示：JVM初始分配的內存由-Xms指定，默認是物理內存的1/64；JVM最大分配的內存由-Xmx指定，默認是物理內存的1/4。

默認空餘堆內存小於40%時，JVM就會增大堆直到-Xmx的最大限制；空餘堆內存大於70%時，JVM會減少堆直到-Xms的最小限制。因此伺服器一般設置-Xms、-Xmx相等以避免在每次GC
後調整堆的大小。

提示：假設物理內存無限大的話，JVM內存的最大值跟操作系統有很大的關系。

簡單的說就32位處理器雖然可控內存空間有4GB,但是具體的操作系統會給一個限制，

這個限制一般是2GB-3GB（一般來說Windows系統下為1.5G-2G，Linux系統下為2G-3G），而64bit以上的處理器就不會有限制了

提示：注意：如果Xms超過了Xmx值，或者堆最大值和非堆最大值的總和超過了物理內存或者操作系統的最大限制都會引起伺服器啟動不起來。

提示：設置NewSize、MaxNewSize相等，"new"的大小最好不要大於"old"的一半，原因是old區如果不夠大會頻繁的觸發"主" GC
，大大降低了性能

JVM使用-XX:PermSize設置非堆內存初始值，默認是物理內存的1/64；

由XX:MaxPermSize設置最大非堆內存的大小，默認是物理內存的1/4。

解決方法：手動設置Heap size

修改TOMCAT_HOME/bin/catalina.bat

在「echo "Using CATALINA_BASE: $CATALINA_BASE"」上面加入以下行：

JAVA_OPTS="-server -Xms800m -Xmx800m -XX:MaxNewSize=256m"

四、性能檢查工具使用

定位內存泄漏：

JProfiler工具主要用於檢查和跟蹤系統（限於Java開發的）的性能。JProfiler可以通過時時的監控系統的內存使用情況，隨時監視垃圾回收，線程運行狀況等手段，從而很好的監視JVM運行情況及其性能。

1. 應用伺服器內存長期不合理佔用，內存經常處於高位佔用，很難回收到低位；

2. 應用伺服器極為不穩定，幾乎每兩天重新啟動一次，有時甚至每天重新啟動一次；

3. 應用伺服器經常做Full GC(Garbage Collection)，而且時間很長，大約需要30-40秒，應用伺服器在做Full
GC的時候是不響應客戶的交易請求的，非常影響系統性能。

因為開發環境和產品環境會有不同，導致該問題發生有時會在產品環境中發生，通常可以使用工具跟蹤系統的內存使用情況，在有些個別情況下或許某個時刻確實是使用了大量內存導致out
of memory，這時應繼續跟蹤看接下來是否會有下降，

如果一直居高不下這肯定就因為程序的原因導致內存泄漏。

五、不健壯代碼的特徵及解決辦法

1、盡早釋放無用對象的引用。好的辦法是使用臨時變數的時候，讓引用變數在退出活動域後，自動設置為null，暗示垃圾收集器來收集該對象，防止發生內存泄露。

對於仍然有指針指向的實例，jvm就不會回收該資源,因為垃圾回收會將值為null的對象作為垃圾，提高GC回收機制效率；

2、我們的程序里不可避免大量使用字元串處理，避免使用String，應大量使用StringBuffer，每一個String對象都得獨立佔用內存一塊區域；

String str = "aaa";

String str2 = "bbb";

String str3 = str + str2;//假如執行此次之後str
,str2以後再不被調用,那它就會被放在內存中等待Java的gc去回收,程序內過多的出現這樣的情況就會報上面的那個錯誤,建議在使用字元串時能使用StringBuffer就不要用String,這樣可以省不少開銷；

3、盡量少用靜態變數，因為靜態變數是全局的，GC不會回收的；

4、避免集中創建對象尤其是大對象，JVM會突然需要大量內存，這時必然會觸發GC優化系統內存環境；顯示的聲明數組空間，而且申請數量還極大。

這是一個案例想定供大家警戒

使用jspsmartUpload作文件上傳,運行過程中經常出現java.outofMemoryError的錯誤，

檢查之後發現問題：組件里的代碼

m_totalBytes = m_request.getContentLength();

m_binArray = new byte[m_totalBytes];

問題原因是totalBytes這個變數得到的數極大，導致該數組分配了很多內存空間，而且該數組不能及時釋放。解決辦法只能換一種更合適的辦法，至少是不會引發outofMemoryError的方式解決。參考：http://bbs.xml.org.cn/blog/more.asp?name=hongrui&id=3747

5、盡量運用對象池技術以提高系統性能；生命周期長的對象擁有生命周期短的對象時容易引發內存泄漏，例如大集合對象擁有大數據量的業務對象的時候，可以考慮分塊進行處理，然後解決一塊釋放一塊的策略。

6、不要在經常調用的方法中創建對象，尤其是忌諱在循環中創建對象。可以適當的使用hashtable，vector
創建一組對象容器，然後從容器中去取那些對象，而不用每次new之後又丟棄

7、一般都是發生在開啟大型文件或跟資料庫一次拿了太多的數據，造成 Out Of Memory Error
的狀況，這時就大概要計算一下數據量的最大值是多少，並且設定所需最小及最大的內存空間值。

㈨ Java在什麼情況下會內存溢出

1 被生命周期極長的集合類不當持有，號稱是Java內存泄漏的首因。
這些集合類的生命周期通常極長，而且是一個輔助管理性質的對象，在一個業務事務運行完後，如果沒有將某個業務對象主
動的從中清除的話，這個集合就會吃越來越多內存.
2 Scope定義不對，這個很簡單了，方法的局部變數定義成類的變數，類的靜態變數等。
3 異常時沒有加finally{}來釋放某些資源，JDBC時代也是很普遍的事情。
4 另外一些我了解不深的原因，如：Swing里的Listener沒有顯式remove；內部類持有外部對象的隱式引用；Finalizers造成關聯對象沒有被及時清空等。

㈩ 哪些情況會內存泄漏

1、資源釋放問題
。 Android 程序代碼的問題，長期保持某些資源，如 Context、Cursor、IO 流的引用，資源得不到釋放造成內存泄露。
2、對象內存過大問題
保存了多個耗用內存過大的對象（如 Bitmap、XML 文件），造成內存超出限制。
3、static 關鍵字的使用問題
static 是 Java 中的一個關鍵字，當用它來修飾成員變數時，那麼該變數就屬於該類，而不是該類的實例。所 以用 static 修飾的變數，它的生命周期是很長的，如果用它來引用一些資源耗費過多的實例（Context 的情況最 多），這時就要謹慎對待了。

public class ClassName { private static Context mContext; //省略 }
1
1
以上的代碼是很危險的，如果將 Activity 賦值到 mContext 的話。那麼即使該 Activity 已經 onDestroy，但是由 於仍有對象保存它的引用，因此該 Activity 依然不會被釋放。
我們舉 Android 文檔中的一個例子。

private static Drawable sBackground;
@Override protected void onCreate(Bundle state) {
super.onCreate(state);
TextView label = new TextView(this); //getApplicationContext label.setText("Leaks are bad");
if (sBackground == null) {
sBackground = getDrawable(R.drawable.large_bitmap);
}
label.setBackgroundDrawable(sBackground); setContentView(label);
}
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
sBackground 是一個靜態的變數，但是我們發現，我們並沒有顯式的保存 Context 的引用，但是，當 Drawable 與 View 連接之後，Drawable 就將 View 設置為一個回調，由於 View 中是包含 Context 的引用的，所以，實際 上我們依然保存了 Context 的引用。這個引用鏈如下： Drawable->TextView->Context 所以，最終該 Context 也沒有得到釋放，發生了內存泄露。
針對 static 的解決方案
① 應該盡量避免 static 成員變數引用資源耗費過多的實例，比如 Context。
② Context 盡量使用 ApplicationContext，因為 Application 的 Context 的生命周期比較長，引用它不會 出現內存泄露的問題。 ③ 使用 WeakReference 代替強引用。比如可以使用 WeakReference mContextRef;
4、線程導致內存溢出
線程產生內存泄露的主要原因在於線程生命周期的不可控。我們來考慮下面一段代碼。
。

public class MyActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
new MyThread().start();
}
private class MyThread extends Thread{
@Override
public void run() {
super.run(); //do somthing while(true)
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14
這段代碼很平常也很簡單，是我們經常使用的形式。我們思考一個問題：假設 MyThread 的 run 函數是一個很費 時的操作，當我們開啟該線程後，將設備的橫屏變為了豎屏，一 般情況下當屏幕轉換時會重新創建 Activity，按照我 們的想法，老的 Activity 應該會被銷毀才對，然而事實上並非如此。 由於我們的線程是 Activity 的內部類，所以 MyThread 中保存了 Activity 的一個引用，當 MyThread 的 run 函 數沒有結束時，MyThread 是不會被銷毀的，因此它所引用的老的 Activity 也不會被銷毀，因此就出現了內存泄露的 問題。有些人喜歡用 Android 提供的 AsyncTask，但事實上 AsyncTask 的問題更加嚴重，Thread 只有在 run 函數不結 束時才出現這種內存泄露問題，然而 AsyncTask 內部的實現機制是運用了 ThreadPoolExcutor,該類產生的 Thread 對 象的生命周期是不確定的，是應用程序無法控制的，因此如果 AsyncTask 作為 Activity 的內部類，就更容易出現內存 泄露的問題。
針對這種線程導致的內存泄露問題的解決方案：
第一、將線程的內部類，改為靜態內部類（因為非靜態內部類擁有外部類對象的強引用，而靜態類則不擁有）。
第二、在線程內部採用弱引用保存 Context 引用。