JVM調優淺談

一.數據類型

java虛擬機中，數據類型可以分為兩類：基本類型和引用類型。基本類型的變量保存原始值，即：它代表的值就是數值本身，而引用類型的變量保存引用值。“引用值”代表了某個對象的引用，而不是對象本身，對象本身存放在這個引用值所表示的地址的位置。

基本類型包括：byte、short、int、long、char、float、double、boolean、returnAddress？？

引用類型包括：類類型、接口類型和數組

二.堆與棧

堆和棧是程序運行的關鍵，很有必要它他們的關系說清楚。

棧是運行時的單位，而堆是存儲的單元。

棧解決程序的運行問題，即程序如何執行，或者說如何處理數據，堆解決的是數據存儲的問題，即數據怎么放，放在哪兒。

在java中一個線程就會相應有一個線程棧與之對應，這點很容易理解，因為不同的線程執行邏輯有所不同，因此需要一個獨立的線程棧。而堆則是所有線程共享的。棧因為是運行單位，因此里面存儲的信息都是跟當前線程（或程序）相關的信息。包括局部變量、程序運行狀態、方法返回值等等，而堆只負責存儲對象信息。

為什么要把堆和棧區分出來呢？棧中不是也可以存儲數據嗎？

1. 從軟件設計的角度看，棧代表了處理邏輯，而堆代表了數據。這樣分開，使得處理邏輯更為清晰。分而治之的思想。這種隔離、模塊化的思想在軟件設計的方方面面都有體現。

2.堆與棧的分離，使得堆中的內容可以被多個棧共享（也可以理解為多個線程訪問同一個對象）。這種共享的收益是很多的。一方面這種共享提供了一種有效的數據交互方式（如：共享內存），另一方面，堆中的共享常量和緩存可以被所有棧訪問，節省了空間。

3. 棧因為運行時的需要，比如保存系統運行的上下文，需要進行地址段的劃分。由于棧只能向上增長，因此就會限制住棧存儲內容的能力，而堆不同，堆中的對象是可以根據需要動態增長的，因此棧和堆的拆分使得動態增長成為可能，相應棧中只需記錄堆中的一個地址即可。

4. 面向對象就是堆和棧的完美結合。其實，面向對象方式的程序與以前結構化的程序在執行上沒有任何區別。但是，面向對象的引入，使得對待問題的思考方式發生了改變，而更接近于自然方式的思考。當我們把對象拆開，你會發現，對象的屬性其實就是數據，存放在堆中；而對象的行為（方法），就是運行邏輯，放在棧中。我們在編寫對象的時候，其實就是編寫了數據結構，也編寫了處理數據的邏輯。不得不承認，面向對象的設計，確實很美。

在java中，Main函數就是棧的起始點，也是程序的起始點。

程序要運行總是有一個起點的。同C語言一樣，java中的Main就是那個起點。無論什么java程序，找到main就找到了程序執行的入口。

堆中存什么？棧中存什么？

堆中存的是對象。棧中存的是基本數據類型和堆中對象的引用。一個對象的大小是不可估計的，或者說是可以動態變化的，但是在棧中，一個對象只對應了一個4byte的引用（堆棧分離的好處）。

為什么不把基本類型放堆中呢？因為其占用的空間一般是1~8個字節---需要空間比較少，而且因為是基本類型，所以不會出現動態增長的情況---長度固定，因此棧中存儲就夠了，如果把它存在堆中是沒有什么意義的（還會浪費空間，后面說明）。可以這么說，基本類型和對象的引用都是存放在棧中，而且都是幾個字節的一個數，因此在程序運行時，它們的處理方式是統一的。但是基本類型、對象引用和對象本身就有所區別了，因為一個是棧中的數據一個是堆中的數據。最常見的一個問題就是，java中參數傳遞時的問題。

java中的參數傳遞是傳值呢？還是傳引用？

1. 不要試圖與C進行類比，java中沒有指針的概念。

2. 程序運行永遠都是在棧中進行的，因而參數傳遞時，只存在傳遞基本類型和對象引用的問題。不會直接傳遞對象本身。

明確以上兩點后。java在方法調用傳遞參數時，因為沒有指針，所以它都是進行傳值調用（這點可以參考C的傳值調用）。因此，很多書里面都說java是進行傳值調用，這點沒有問題，而且也簡化了C中復雜性。

但是傳引用的錯覺是如何造成的呢？在運行棧中，基本類型和引用的處理是一樣的，都是傳值，所以，如果是傳引用的方法調用，也同時可以理解為“傳引用值”的傳值調用，即引用的處理跟基本類型是完全一樣的。但是當進入被調用方法時，被傳遞的這個引用的值，被程序解釋（或者查找）到堆中的對象，這個時候才對應到真正的對象。如果此時進行修改，修改的是引用對應的對象，而不是對象本身，即：修改的是堆中的數據。所以這個修改是可以保持的。

對象，從某種意義上說，是由基本類型組成的。可以把一個對象看作為一棵樹，對象的屬性如果還是對象，則還是一棵樹（即非葉子節點），基本類型則為樹的葉子節點。程序參數傳遞時，被傳遞的值本身都是不能進行修改的，但是，如果這個值是一個非葉子節點（即一個對象引用），則可以修改這個節點下面的所有內容。

堆和棧中，棧是程序運行最根本的東西。程序運行可以沒有堆，但是不能沒有棧。而堆是為棧進行數據存儲服務的，說白了堆就是一塊共享的內存。不過，正是因為堆和棧的分離的思想，才使得java的垃圾回收成為可能。

java中，棧的大小通過-Xss來設置，當棧中存儲的數據比較多時，需要適當調大這個值，否則會出現 java.lang.StackOverflowError異常。常見的出現這個異常的是無法返回的遞歸，因為此時棧中保存的信息都是方法返回的記錄點。

java對象的大小

基本數據類型的大小是固定的，這里就不多說了，對于非基本類型的java對象，其大小就值得商討。

在java中，一個空Object對象的大小是8byte，這個大小只是保存堆中一個沒有任何屬性的對象的大小。看看下面語句：

Object ob = new Object();

這樣在程序中完成了一個java對象的聲明，但是它所占的空間為：4byte+8byte。4byte是上面部分所說的java棧中保存引用的所需要空間。

而那8byte則是java堆中對象的信息。因為所有的java非基本類型的對象都需要默認繼承Object對象，因此不論什么樣的java對象，其大小都必須是大于8byte。

有了Object對象的大小，我們就可以計算其他對象的大小了。

其大小為：空對象大小(8byte)+int大小(4byte)+Boolea大小(1byte)+空Object引用的大小(4byte)=17byte。但是因為java在對對象內存分配時都是以8的整數倍來分的，因此大于17byte的最接近8的整數倍的是24，因此此對象的大小為24byte。

這里需要注意一下基本類型的包裝類型的大小。因為這種包裝類型已經成為對象了，因此需要把它們作為對象來看待。包裝類型的大小至少是12byte(聲明一個空Object至少需要的空間)，而且12byte沒有包含任何有效信息，同時，因為java對象大小是8的整數倍，因此一個基本類型包裝類的大小至少是16byte。這個內存占用是很恐怖的，它是使用基本類型的N倍(N>2)，這些類型的內存占用更是夸張。因此，可能的話應盡量少使用包裝類。在JDK5.0以后，因為加入了自動類型裝換，因此，java虛擬機會在存儲方面進行相應的優化。

引用類型

對象引用類型分為強引用、軟引用、弱引用和虛引用

強引用：就是我們一般聲明對象時虛擬機生成的引用，強引用環境下，垃圾回收時需要嚴格判斷當前對象是否被強引用，如果被強引用，則不會被垃圾回收。

軟引用：軟引用一般被作為緩存來使用。與強引用的區別是，軟引用在垃圾回收時，虛擬機會根據當前系統的剩余內存來決定是否對軟引用進行回收。如果剩余內存比較緊張，則虛擬機會回收軟引用所引用的空間，如果剩余內存相對富裕，則不會進行回收。換句話說，虛擬機在發生OutOfMemory時，肯定是沒有軟引用存在的。在此我向大家推薦一個架構學習交流圈。交流學習企鵝圈號：948368769 里面會分享一些資深架構師錄制的視頻錄像：有Spring，MyBatis，Netty源碼分析，高并發、高性能、分布式、微服務架構的原理，JVM性能優化、分布式架構等這些成為架構師必備的知識體系。還能領取免費的學習資源，目前受益良多

弱引用：弱引用與軟引用類似，都是作為緩存來使用。但與軟引用不同，弱引用在進行垃圾回收時，是一定會被回收掉的，因此其生命周期只存在于一個垃圾回收周期內。

強引用不用說，我們系統一般在使用時都是用的強引用。而“軟引用”和“弱引用”比較少見。他們一般被作為緩存使用，而且一般是在內存比較受限的情況下作為緩存。

因為如果內存足夠大的話，可以直接使用強引用作為緩存即可，同時可控性更高。因而，他們常見的是被使用在桌面應用系統的緩存。

“虛引用”顧名思義，就是形同虛設，與其他幾種引用都不同，虛引用并不會決定對象的生命周期。如果一個對象僅持有虛引用，那么它就和沒有任何引用一樣，在任何時候都可能被垃圾回收器回收。

虛引用主要用來跟蹤對象被垃圾回收器回收的活動。虛引用與軟引用和弱引用的一個區別在于：虛引用必須和引用隊列（ReferenceQueue）聯合使用。當垃圾回收器準備回收一個對象時，如果發現它還有虛引用，就會在回收對象的內存之前，把這個虛引用加入到與之 關聯的引用隊列中。

ReferenceQueue queue = new ReferenceQueue ();

PhantomReference pr = new PhantomReference (object, queue);

程序可以通過判斷引用隊列中是否已經加入了虛引用，來了解被引用的對象是否將要被垃圾回收。如果程序發現某個虛引用已經被加入到引用隊列，那么就可以在所引用的對象的內存被回收之前采取必要的行動。

可以從不同的角度去劃分垃圾回收算法：

按照基本回收策略分

引用計數（Reference Counting）

比較古老的回收算法。原理是此對象有一個引用，即增加一個計數，刪除一個引用則減少一個計數。垃圾回收時，只用收集計數為0的對象。此算法最致命的是無法處理循環引用的問題。

標記-清除（Mark-Sweep）

此算法執行分兩階段。第一階段從引用根節點開始標記所有被引用的對象，第二階段遍歷整個堆，把未標記的對象清除。此算法需要暫停整個應用，同時，會產生內存碎片。

復制（Copying）

此算法把內存空間劃分為兩個相等的區域，每次只是用其中一個區域。垃圾回收時，遍歷當前使用區域，把正在使用中的對象復制到另外一個區域中。此算法每次只處理正在使用中的對象，因此復制成本比較小，同時復制過去以后還能進行相應的內存整理，不會出現“碎片”問題？？。當然，此算法的缺點也是比較明顯的，就是需要兩倍內存空間。

標記-整理（Mark-Compact）

此算法結合了“標記-清除”和“復制”兩個算法的優點。也是分兩個階段，第一階段從根節點開始標記所有被引用對象，第二階段遍歷整個堆，把清除未標記對象并且把存活對象“壓縮”到堆中的其中一塊，按順序排放。此算法避免了“標記-清除”的碎片問題，同時也避免了“復制”算法的空間問題。

按分區對待的方式分

增量收集（Incremental Collecting）：實時垃圾回收算法，即：在應用進行的同時進行垃圾回收。不知道什么原因JDK5.0中的收集器沒有使用這種算法。

分代收集（Generational Collecting）：基于對對象生命周期分析后得出的垃圾回收算法。把對象分為年輕代、年老代、持久代，對不同生命周期的對象使用不同的算法（上述方式中的一個）進行回收。現在的垃圾回收器（從J2SE1.2開始）都是使用此算法的。

按系統線程分

串行收集：串行收集使用單線程處理所有垃圾回收工作，因為無需多線程交互，實現容易，而且效率比較高。但是，其局限性也比較明顯，即無法使用多處理器的優勢，所以此收集適合單處理器機器。當然，此收集器也可以用在小數據量（100M左右）情況下的多處理器機器上。

并行收集：并行收集使用多線程處理垃圾回收工作，因而速度快，效率高。而且理論上CPU數目越多，越能體現出并行收集器的優勢。

并發收集：GC線程和應用線程大部分時間是并發執行，只是在初始標記（initial mark）和二次標記（remark）時需要stop-the-world，這可以大大縮短停頓時間（pause time），所以適用于響應時間優先的應用，減少用戶等待時間。由于GC是和應用線程并發執行，只有在多CPU場景下才能發揮其價值，在執行過程中還會產生新的垃圾floating garbage，如果等空間滿了再開始GC，那這些新產生的垃圾就沒地方放了，這時就會啟動一次串行GC，等待時間將會很長，所以要在空間還未滿時就要啟動GC。mark和sweep操作會引起很多碎片，所以間隔一段時間需要整理整個空間，否則遇到大對象，沒有連續空間也會啟動一次串行GC。采用此收集器（如tenured generation），收集頻率不能大，否則會影響到cpu的利用率，進而影響吞吐量。。

如何區分垃圾

上面說到的“引用計數”法，通過統計控制生成對象和刪除對象是的引用數來判斷。垃圾回收程序收集計數為0的對象即可。但是這種方法無法解決循環引用。所以，后來實現的垃圾判斷算法中，都是從程序運行的根節點出發，遍歷整個對象引用，查找存活的對象，那么在這種方式的實現中，垃圾回收從哪兒開始的呢？即，從哪兒開始查找哪些對象是正在被當前系統使用的，上面分析的堆和棧的區別，其中棧是真正進行程序執行的地方，所以要獲取哪些對象正在被使用，則需要從java棧開始。同時，一個棧是與一個線程對應的，因此，如果有多個線程的話，則必須對這些線程對應的所有的棧進行檢查。

同時，除了棧外，還有系統運行時的寄存器等，也是存儲程序運行數據的。這樣，以棧或寄存器中的引用為起點，我們可以找到堆中的對象，又從這些對象找到對堆中其它對象的引用，這種引用逐步擴展，最終以null引用或者基本類型結束，這樣就形成了一顆以java棧中引用所對應的對象為根節點的一顆對象樹，如果棧中有多個引用，則最終會形成多顆對象樹。在這些對象樹上的對象，都是當前系統運行所需要的對象，不能被垃圾回收，而其他剩余對象，則可以視為無法被引用到的對象，可以被當做垃圾進行回收。

因此，垃圾回收的起點是一些根對象（java棧、靜態變量、寄存器...）。而最簡單的java棧就是java程序執行的main函數。這種回收方式，也是上面提到的“標記-清除”的回收方式。

如何處理碎片

由于不同java對象存活時間是不一定的，因此，在程序運行一段時間以后，如果不進行內存整理，就會出現零散的內存碎片。碎片最直接的問題就是會導致無法分配大塊的內存空間，以及程序運行效率降低。所以，在上面提到的基本垃圾回收算法中 ，“復制”方式和“標記-整理”方式，都可以解決碎片的問題。

如何解決同時存在的對象創建和對象回收問題

垃圾回收線程是回收內存的，而程序運行線程則是消耗（或分配）內存的，一個回收內存，一個分配內存，從這點看，兩者是矛盾的。因此，在現有的垃圾回收方式中，要進行垃圾回收前，一般都需要暫停整個應用（即：暫停內存的分配），然后進行垃圾回收，回收完成后再繼續應用。這種實現方式是最直接，而且最有效的解決二者矛盾的方式。

但是這種方式有一個很明顯的弊端，就是當堆空間持續增大時，垃圾回收的時間也將會相應的持續增大，相應應用暫停的時間也會相應的增大。一些相應時間要求很高的應用，比如最大暫停時間要求是幾百毫秒，那么當堆空間大于幾個G時，就很有可能超過這個限制，在這種情況下，垃圾回收將會成為系統運行的一個瓶頸。為解決這種矛盾，有了并發垃圾回收算法，使用這種算法，垃圾回收線程與程序運行線程同時運行。在這種方式下，解決了暫停的問題，但是因為需要在新生成對象的同時又要回收對象，算法復雜性會大大增加，系統的處理能力也會相應降低，同時，“碎片”問題將會比較難解決，以后研究的重點！！！！！！。

為什么要分代

分代的垃圾回收策略，是基于這樣一個事實：不同的對象的生命周期是不一樣的。因此，不同聲明周期的對象可以采取不同的收集方式，以便提高回收效率。

在Java程序運行的過程中，會產生大量的對象，其中有些對象是與業務信息相關，比如Http請求中的Session對象、線程、Socket連接，這類對象跟業務直接掛鉤，因此生命周期比較長。但是還有一些對象，主要是程序運行過程中生成的臨時變量，這些對象生命周期比較短，比如：String對象，由于其不變類的特性，系統會產生大量的這些對象，有些對象甚至只用一次即可回收。

是想，在不進行對象存活時間區分的情況下，每次垃圾回收都是對整個堆空間進行回收，花費時間相對會長，同時，因為每次回收都需要遍歷所有存活對象，但實際上，對于生命周期長的對象而言，這種遍歷是沒有效果的，因為可能進行了很多次遍歷，但是它們依舊存在。因此，分代垃圾回收采用分治的思想，進行代的劃分，把不同生命周期的對象放在不同代上，不同代上采用最適合它的垃圾回收方式進行回收。

如何分代

如圖所示：

虛擬機中共劃分了三個代：年輕代（Young Generation）、年老代（Old Generation）和持久代（Permanent Generation）。

其中持久代主要存放的是java類的類信息，與垃圾收集要收集的java對象關系不大。年輕代和年老代的劃分是對垃圾收集影響比較大的。

年輕代：

所有新生成的對象首先都是放在年輕代的。年輕代的目標就是盡可能快速的收集掉那些生命周期短的對象。年輕代分為三個區。一個Eden區，兩個Survivor區（一般而言）。大部分對象在Eden區中生成。當Eden區滿時，還存活的對象將被復制到Survivor區（兩個中的一個），當這個Survivor區滿時，此區的存活將被復制到另外一個Survivor區，當這個Survivor區也滿了的時候，從第一個Survivor區復制過來的并且此時還存活的對象，將被復制“年老區（Tenured）”。需要注意，Survivor的兩個區是對稱的，沒先后關系，所以同一個區中可能同時存在從Eden復制過來的對象和從前一個Survivor復制過來的對象，而復制到年老區的只有從第一個Survivor區過來的對象。而且，Survivor區總有一個是空的。同時，根據程序需要，Survivor區是可以配置為多個的（多于兩個），這樣可以增加對象在年輕代中的存在時間，減少被放到年老代的可能。在此我向大家推薦一個架構學習交流圈。交流學習企鵝圈號：948368769 里面會分享一些資深架構師錄制的視頻錄像：有Spring，MyBatis，Netty源碼分析，高并發、高性能、分布式、微服務架構的原理，JVM性能優化、分布式架構等這些成為架構師必備的知識體系。還能領取免費的學習資源，目前受益良多

年老代：

在年輕代中經歷了N次垃圾回收后仍然存活的對象，就會被放到年老代中。因此，可以認為年老代中存放的都是一些生命周期較長的對象。

持久代：

用于存放靜態文件，如java類、方法等。持久代對垃圾回收沒有顯著影響，但是有些應用可能動態生成或者調用一些class,例如Hibernate等，在這種時候需要設置一個比較大的持久空間來存放這些運行過程中新增的類。持久代大小通過 -XX:MaxPermSize = <N> 進行設置。

什么情況下觸發垃圾回收

由于對象進行了分代處理，因此垃圾回收區域、時間也不一樣。GC有兩種類型：Scavenge GC 和 Full GC

Scavenge GC

一般情況下，當新對象生成，并且在Eden申請空間失敗時，就會觸發Scavenge GC，對Eden區域進行GC，清除非存活對象，并且把尚且存活的對象移動到Survivor區。然后整理Survivor的兩個區。這種方式的GC是對年輕代的Eden區進行，不會影響到年老代。因為大部分對象都是從Eden區開始的，同時Eden區不會分配的很大，所以Eden區的GC會頻繁進行。因而，一般在這里需要使用速度快、效率高的算法，使Eden區能盡快空閑出來。

Full GC

對整個堆進行整理，包括Young、Tenured 和 Perm。Full GC 因為需要對整個堆進行回收，所以比 Scavenge GC 要慢，因此應該盡可能減少 Full GC 的次數。在對JVM調優的過程中，很大一部分工作就是對于 Full GC 的調節。

有如下原因可能導致Full GC:

. 年老代（Tenured）被寫滿

. 持久代（Perm）被寫滿

. System.gc()被顯式調用

. 上一次GC之后Heap的各域分配策略動態變化

分代垃圾回收流程示意

選擇合適的垃圾收集算法

串行收集器

用單線程處理所有垃圾回收工作，因為無需多線程交互，所有效率比較高。但是，也無法使用多處理器的優勢，所以此收集器適合單處理器機器。當然，此收集器也可以用在小數據量（100M左右）情況下的多處理器機器上。可以使用 -XX:+UseSerialGC打開。

并行收集器

對年輕代進行并行垃圾回收，因此可以減少垃圾回收時間。一般在多線程多處理器機器上使用。使用 -XX:+UseParallelGC 打開。并行收集器在 J2SE5.0第六6更新上引入，在java SE6.0中進行了增強 --- 可以對年老代進行并行收集。如果年老代不使用并行收集的話，默認是使用單線程進行垃圾回收，因此會制約擴展能力。使用 -XX:+UseParallelOldGC打開。

使用 -XX:ParallelGCThreads = <N> 設置并行垃圾回收的線程數。此值可以設置與機器處理器數量相等。

此收集器可以進行如下配置：

最大垃圾回收暫停：指定垃圾回收時的最長暫停時間，通過-XX:MaxGCPauseMillis = <N>指定。<N> 為毫秒，如果指定了此值的話，堆大小和垃圾回收相關參數會進行調整以達到指定值。設定此值可能會減少應用的吞吐量。

吞吐量：吞吐量為垃圾回收時間與非垃圾回收時間的比值，通過-XX:GCTimeRatio = <N> 來設定，公式為 1/(1 + N)。例如，-XX:GCTimeRatio = 19時，表示5%的時間用于垃圾回收。默認情況為99，即1%的時間用于垃圾回收。

并發收集器

可以保證大部分工作都并發進行（應用不停止），垃圾回收只暫停很少的時間，此收集器適合對響應時間要求比較高的中、大規模應用。使用 -XX:+UseConcMarkSweepGC打開。

并發收集器主要減少年老代的暫停時間，它在應用不停止的情況下使用獨立的垃圾回收線程，跟蹤可達對象。在每個年老代垃圾回收周期中，在收集初期并發收集器會對整個應用進行簡短的暫停。在收集中還會再暫停一次。第二次暫停會比第一次稍長，在此過程中多個線程同時進行垃圾回收工作。

并發收集器使用處理器換來短暫的停頓時間。在一個N個處理器的系統上，并發收集部分使用 k/N 個可用處理器進行回收，一般情況下 1 <= k <= N / 4。

在只有一個處理器的主機上使用并發收集器，設置為 incremental mode 模式也可獲得較短的停頓時間。

浮動垃圾：由于在應用運行的同時進行垃圾回收，所以有些垃圾可能在垃圾回收進行完成時產生，這樣就造成了“Floating Garbage”，這些垃圾需要在下次垃圾回收周期時才能回收掉。所以，并發收集器一般需要20%的預留空間用于這些浮動垃圾。在此我向大家推薦一個架構學習交流圈。架構交流學習企鵝圈號：948368769 里面會分享一些資深架構師錄制的視頻錄像：有Spring，MyBatis，Netty源碼分析，高并發、高性能、分布式、微服務架構的原理，JVM性能優化、分布式架構等這些成為架構師必備的知識體系。還能領取免費的學習資源，目前受益良多

Concurrent Mode Failure：并發收集器在應用運行時進行收集，所以需要保證堆在垃圾回收的這段時間有足夠的空間供程序使用，否則，垃圾回收還未完成，堆空間先滿了。這種情況下將會發生“并發模式失敗”，此時整個應用將會暫停，進行垃圾回收。

啟動并發收集器：因為并發收集在應用運行時進行收集，所以必須保證收集完成之前有足夠的內存空間供程序使用，否則會出現“Concurrent Mode Failure”。通過設置 -XX:CMSInitiatingOccupancyFraction = <N> 指定還有多少剩余堆是開始執行并發收集。

小結

串行處理器：

-- 適用情況：數據量比較小（100M左右），單處理器下并且對相應時間無要求的應用。

-- 缺點：只能用于小型應用。

并行處理器：

-- 適用情況：“對吞吐量有高要求”，多CPU，對應用過響應時間無要求的中、大型應用。舉例：后臺處理、科學計算。

-- 缺點：垃圾收集過程中應用響應時間可能加長。

并發處理器：

-- 適用情況：“對響應時間有高要求”，多CPU，對應用響應時間有較高要求的中、大型應用。舉例：Web服務器/應用服務器、電信交換、集成開發環境。

以下配置主要針對分代垃圾回收算法而言。

堆大小設置

年輕代的設置很關鍵

JVM中最大堆大小有三方面限制：相關操作系統的數據模型（32-bit 還是64-bit）限制；系統的可用虛擬內存限制；系統的可用物理內存限制。32位系統下，一般限制在1.5G~2G；64位操作系統對內存無限制。在Windows Server 2003系統，3.5G物理內存，JDK5.0下測試，最大可設置為1478m。

典型設置：

java -Xmx3550m -Xms3550m -Xmn2g -Xss128k

-Xmx3550m：設置JVM最大可用內存為3550m。

-Xms3550m：設置JVM初始內存為3550m。此值可以設置與 -Xmx 相同，以避免每次垃圾回收完成后JVM重新分配內存。

-Xmn2g：設置年輕代大小為2G。整個堆大小=年輕代大小+年老代大小+持久代大小。持久代一般固定大小為64m，所以增大年輕代后，將會減小年老代大小。此值對系統性能影響較大，Sun官方推薦配置為整個堆的3/8。

-Xss128k：設置每個線程的堆棧大小。JDK5.0以后每個線程堆棧大小為1M，以前每個線程堆棧大小為256k。根據應用的線程所需內存大小進行調整。在相同物理內存下，減小這個值能生成更多的線程。但是操作系統對一個進程內的線程數還是有限制的，不能無限生成，經驗值在3000~5000左右。

java -Xmx3550m -Xms3550m -Xss128k -XX:NewRatio=4 -XX:SurvivorRatio=4 -XX:MaxPermSize=16m -XX:MaxTenuringThreshold=0

-XX:NewRatio=4：設置年輕代（包括Eden和兩個Survivor區）與年老代的比值（除去持久代）。設置為4，則年輕代與年老代所占比值為1:4，年輕代占整個堆棧的1/5。

-XX:SurvivorRatio=4：設置年輕代中Eden區與Survivor區的大小比值。設置為4，則兩個Survivor區與一個Eden區的比值為2:4，一個Survivor區占整個年輕代的1/6。

-XX:MaxPermSize=16m：設置持久代大小為16m。

-XX:MaxTenuringThreshold=0：設置垃圾最大年齡。如果設置為0的話，則年輕代對象不經過Survivor區，直接進入年老代。對于年老代比較多的應用，可以提高效率。如果此值設置為一個較大值，則年輕代對象會在Survivor區進行多次復制，這樣可以增加對象在年輕代的存活時間，增加在年輕代被回收的概率。

回收器選擇

JVM給了三種選擇：串行收集器、并行收集器、并發收集器，但是串行收集器只適用于小數據量的情況，所以這里的選擇主要針對并行收集器和并發收集器。默認情況下，JDK5.0以前都是使用串行收集器，如果想使用其他收集器需要在啟動的時候加入相應參數。JDK5.0以后，JVM會根據當前系統配置進行判斷。

吞吐量優先的并行收集器

如上文所述，并行收集器主要以到達一定的吞吐量為目標，適用于科學計算和后臺處理等。

典型配置：

java -Xmx3800m -Xms3800m -Xmn2g -Xss128k -XX:+UseParallelGC -XX:ParallelGCThreads=20

-XX:+UseParallelGC：選擇垃圾收集器為并行收集器。此配置僅對年輕代有效。即上述配置下，年輕代使用并發收集，而年老代仍舊使用串行收集。

-XX:+ParallelGCThreads=20：配置并行收集器的線程數，即：同時多少個線程一起進行垃圾回收。此值最好配置與處理器數目相等。

java -Xmx3550m -Xms3550m -Xmn2g -Xss128k -XX:+UseParallelGC -XX:ParallelGCThreads=20 -XX:+UseParallelOldGC

-XX:+UseParallelOldGC：配置年老代垃圾收集方式為并行收集。JDK6.0支持對年老代并行收集。

java -Xmx3550m -Xms3550m -Xmn2g -Xss128k -XX:+UseParallelGC -XX:MaxGCPauseMillis=100

-XX:MaxGCPauseMillis=100：設置每次年輕代垃圾回收的最長時間，如果無法滿足此時間，JVM會自動調整年輕代大小，以滿足此值。

java -Xmx3550m -Xms3550m -Xmn2g -Xss128k -XX:+UseParallelGC -XX:MaxGCPauseMillis=100 -XX:+UseAdaptiveSizePolicy

-XX:+UseAdaptiveSizePolicy：設置此選項后，并行收集器會自動選擇年輕代區大小和相應的Survivor區比例，以達到目標系統規定的最低響應時間或者收集頻率等，此值建議使用并行收集器時，一直打開。

響應時間優先的并發收集器

如上文所述，并發收集器主要是保證系統的響應時間，減少垃圾收集時的停頓時間。適用于應用服務器、電信領域等。

典型配置：

java -Xmx3550m -Xms3550 -Xmn2g -Xss128k -XX:ParallelGCThreads=20 -XX:+UseConcMarkSweepGC -XX:+UseParNewGC

-XX:+UseConcMarkSweepGC：設置年老代為并發收集。測試中配置這個以后，-XX:NewRatio=4的配置失效了，原因不明。所以，此時年輕代大小最好用-Xmn設置。

-XX:+UseParNewGC：設置年輕代為并行收集。可與CMS收集同時使用。JDK5.0以上，JVM會根據系統配置自行設置，所以無需再設置此值。

java -Xmx3550m -Xms3550 -Xmn2g -Xss128k -XX:+UseConcMarkSweepGC -XX:CMSFullGCsBeforeCompaction=5 -XX:+UseCMSCompactAtFullCollection

-XX:CMSFullGCsBeforeCompaction：由于并發收集器不對內存空間進行壓縮、整理，所以運行一段時間后會產生“碎片”，使得運行效率降低。此值設置運行多少次GC以后對內存空間進行壓縮、整理。

-XX:+UseCMSCompactAtFullCollection：打開對年老代的壓縮。可能會影響性能，但是可以消除碎片。

常見配置匯總

堆設置

-Xms：初始堆大小

-Xmx：最大堆大小

-XX:NewSize=n：設置年輕代大小

-XX:NewRatio=n：設置年輕代和年老代的比值。如：為3，表示年輕代與年老代比值為1：3，表示Eden：Survivor=3:2，一個Survivor區占整個年輕代的1/5。

-XX:MaxPermSize=n：設置持久代大小

收集器設置

-XX:+UseSerialGC：設置串行收集器

-XX:+UseParallelGC：設置并行收集器

-XX:+UseParalledlOldGC：設置并行年老代收集器

-XX:+UseConcMarkSweepGC：設置并發收集器

垃圾回收統計信息

-XX:+PrintGC

-XX:+PrintGCDetails

-XX:+PrintGCTimeStamps

-Xloggc:filename

并行收集器設置

-XX:ParallelGCThreads=n：設置并行收集器收集時使用的CPU數。并行收集線程數。

-XX:MaxGCPauseMillis=n：設置并行收集最大暫停時間

-XX:GCTimeRatio=n：設置垃圾回收時間占程序運行時間的百分比。公式為1/(1+N)

并發收集器設置

-XX:+CMSIncrementalMode：設置為增量模式。適用于單CPU情況。

-XX:+ParallelGCThreads=n：設置并發收集器年輕代收集方式為并行收集時，使用的CPU數。并行收集線