JVM之永久代（PermGen）和元空間（Metaspace）
轉載自：http://www.cnblogs.com/paddix/p/5309550.html
從jdk開始，就開始了永久代的轉移工作，將譬如符號引用(Symbols)轉移到了native heap；字面量(interned strings)轉移到了java heap；類的靜態變數(class statics)轉移到了java heap。但是永久在還存在於JDK7中，直到JDK8，永久代才完全消失，轉而使用元空間。而元空間是直接存在記憶體中，不在java虛擬機器中的，因此元空間依賴於記憶體大小。當然你也可以自定義元空間大小。
為什麼叫元空間，是因為這裡面儲存的是類的元資料資訊
元資料（Meta Date），關於資料的資料或者叫做用來描述資料的資料或者叫做資訊的資訊。
這些定義都很是抽象，我們可以把元資料簡單的理解成，最小的資料單位。元資料可以為資料說明其元素或屬性（名稱、大小、資料型別、等），或其結構（長度、欄位、資料列），或其相關資料（位於何處、如何聯絡、擁有者）
為什麼這麼做呢？
類的元資料, 字串池, 類的靜態變數將會從永久代移除, 放入Java heap或者native memory. 其中建議JVM的實現中將類的元資料放入 native memory, 將字串池和類的靜態變數放入Java堆中. 這樣可以載入多少類的元資料就不在由MaxPermSize控制, 而由系統的實際可用空間來控制.
為什麼這麼做呢? 減少OOM只是表因, 更深層的原因還是要合併HotSpot和JRockit的程式碼, JRockit從來沒有一個叫永久代的東西, 但是執行良好, 也不需要開發運維人員設定這麼一個永久代的大小.
符號引用：編譯時生成的對某個物件的引用。
一、JVM 記憶體模型
根據 JVM 規範，JVM 記憶體共分為虛擬機器棧、堆、方法區、程式計數器、本地方法棧五個部分。
1、虛擬機器棧：每個執行緒有一個私有的棧，隨著執行緒的建立而建立。棧裡面存著的是一種叫“棧幀”的東西，每個方法會建立一個棧幀，棧幀中存放了區域性變量表（基本資料型別和物件引用）、運算元棧、方法出口等資訊。棧的大小可以固定也可以動態擴充套件。當棧呼叫深度大於JVM所允許的範圍，會丟擲StackOverflowError的錯誤，不過這個深度範圍不是一個恆定的值，我們通過下面這段程式可以測試一下這個結果：
棧溢位測試原始碼：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
package com.paddx.test.memory;
public class StackErrorMock
{
private static int index
= 1;
public void call(){
index++;
call();
}
public static void main(String[]
args) {
StackErrorMock
mock = new StackErrorMock();
try {
mock.call();
}catch (Throwable
e){
System.out.println("Stack
deep : "+index);
e.printStackTrace();
}
}
}
|
程式碼段 1
執行三次，可以看出每次棧的深度都是不一樣的，輸出結果如下。
至於紅色框裡的值是怎麼出來的，就需要深入到 JVM 的原始碼中才能探討，這裡不作詳細闡述。
虛擬機器棧除了上述錯誤外，還有另一種錯誤，那就是當申請不到空間時，會丟擲 OutOfMemoryError。這裡有一個小細節需要注意，catch 捕獲的是 Throwable，而不是 Exception。因為 StackOverflowError 和 OutOfMemoryError 都不屬於 Exception 的子類。
2、本地方法棧：
這部分主要與虛擬機器用到的 Native 方法相關，一般情況下， Java 應用程式設計師並不需要關心這部分的內容。
3、PC 暫存器：
PC 暫存器，也叫程式計數器。JVM支援多個執行緒同時執行，每個執行緒都有自己的程式計數器。倘若當前執行的是 JVM 的方法，則該暫存器中儲存當前執行指令的地址；倘若執行的是native 方法，則PC暫存器中為空。
4、堆
堆記憶體是 JVM 所有執行緒共享的部分，在虛擬機器啟動的時候就已經建立。所有的物件和陣列都在堆上進行分配。這部分空間可通過 GC 進行回收。當申請不到空間時會丟擲 OutOfMemoryError。下面我們簡單的模擬一個堆記憶體溢位的情況：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package com.paddx.test.memory;
import java.util.ArrayList;
import java.util.List;
public class HeapOomMock
{
public static void main(String[]
args) {
List<byte[]>
list = new ArrayList<byte[]>();
int i
= 0;
boolean flag
= true;
while (flag){
try {
i++;
list.add(new byte[1024 * 1024]);//每次增加一個1M大小的陣列物件
}catch (Throwable
e){
e.printStackTrace();
flag
= false;
System.out.println("count="+i);//記錄執行的次數
}
}
}
}
|
程式碼段 2
執行上述程式碼，輸出結果如下：
注意，這裡我指定了堆記憶體的大小為16M，所以這個地方顯示的count=14（這個數字不是固定的），至於為什麼會是14或其他數字，需要根據 GC 日誌來判斷，具體原因會在下篇文章中給大家解釋。
5、方法區：
方法區也是所有執行緒共享。主要用於儲存類的資訊、常量池、方法資料、方法程式碼等。方法區邏輯上屬於堆的一部分，但是為了與堆進行區分，通常又叫“非堆”。 關於方法區記憶體溢位的問題會在下文中詳細探討。
二、PermGen（永久代）
絕大部分 Java 程式設計師應該都見過 “java.lang.OutOfMemoryError: PermGen space ”這個異常。這裡的 “PermGen space”其實指的就是方法區。不過方法區和“PermGen space”又有著本質的區別。前者是 JVM 的規範，而後者則是 JVM 規範的一種實現，並且只有 HotSpot 才有 “PermGen space”，而對於其他型別的虛擬機器，如 JRockit（Oracle）、J9（IBM） 並沒有“PermGen space”。由於方法區主要儲存類的相關資訊，所以對於動態生成類的情況比較容易出現永久代的記憶體溢位。最典型的場景就是，在 jsp 頁面比較多的情況，容易出現永久代記憶體溢位。我們現在通過動態生成類來模擬 “PermGen space”的記憶體溢位：
| 1 2 3 4 |
package com.paddx.test.memory;
public class Test
{
}
|
程式碼段 3
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
package com.paddx.test.memory;
import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;
public class PermGenOomMock{
public static void main(String[]
args) {
URL
url = null;
List<ClassLoader>
classLoaderList = new ArrayList<ClassLoader>();
try {
url
= new File("/tmp").toURI().toURL();
URL[]
urls = {url};
while (true){
ClassLoader
loader = new URLClassLoader(urls);
classLoaderList.add(loader);
loader.loadClass("com.paddx.test.memory.Test");
}
} catch (Exception
e) {
e.printStackTrace();
}
}
}
|
程式碼段 4
執行結果如下：
本例中使用的 JDK 版本是 1.7，指定的 PermGen 區的大小為 8M。通過每次生成不同URLClassLoader物件來載入Test類，從而生成不同的類物件，這樣就能看到我們熟悉的 “java.lang.OutOfMemoryError: PermGen space ” 異常了。這裡之所以採用 JDK 1.7，是因為在 JDK 1.8 中， HotSpot 已經沒有 “PermGen space”這個區間了，取而代之是一個叫做 Metaspace（元空間） 的東西。下面我們就來看看 Metaspace 與 PermGen space 的區別。
三、Metaspace（元空間）
其實，移除永久代的工作從JDK1.7就開始了。JDK1.7中，儲存在永久代的部分資料就已經轉移到了Java Heap或者是 Native Heap。但永久代仍存在於JDK1.7中，並沒完全移除，譬如符號引用(Symbols)轉移到了native heap；字面量(interned strings)轉移到了java heap；類的靜態變數(class statics)轉移到了java heap。我們可以通過一段程式來比較 JDK 1.6 與 JDK 1.7及 JDK 1.8 的區別，以字串常量為例：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
package com.paddx.test.memory;
import java.util.ArrayList;
import java.util.List;
public class StringOomMock
{
static String
base = "string";
public static void main(String[]
args) {
List<String>
list = new ArrayList<String>();
for (int i=0;i<
Integer.MAX_VALUE;i++){
String
str = base + base;
base
= str;
list.add(str.intern());
}
}
}
|
這段程式以2的指數級不斷的生成新的字串，這樣可以比較快速的消耗記憶體。我們通過 JDK 1.6、JDK 1.7 和 JDK 1.8 分別執行：
JDK 1.6 的執行結果：
JDK 1.7的執行結果：
JDK 1.8的執行結果：
從上述結果可以看出，JDK 1.6下，會出現“PermGen Space”的記憶體溢位，而在 JDK 1.7和 JDK 1.8 中，會出現堆記憶體溢位，並且 JDK 1.8中 PermSize 和 MaxPermGen 已經無效。因此，可以大致驗證 JDK 1.7 和 1.8 將字串常量由永久代轉移到堆中，並且 JDK 1.8 中已經不存在永久代的結論。現在我們看看元空間到底是一個什麼東西？
元空間的本質和永久代類似，都是對JVM規範中方法區的實現。不過元空間與永久代之間最大的區別在於：元空間並不在虛擬機器中，而是使用本地記憶體。因此，預設情況下，元空間的大小僅受本地記憶體限制，但可以通過以下引數來指定元空間的大小：
-XX:MetaspaceSize，初始空間大小，達到該值就會觸發垃圾收集進行型別解除安裝，同時GC會對該值進行調整：如果釋放了大量的空間，就適當降低該值；如果釋放了很少的空間，那麼在不超過MaxMetaspaceSize時，適當提高該值。
-XX:MaxMetaspaceSize，最大空間，預設是沒有限制的。
除了上面兩個指定大小的選項以外，還有兩個與 GC 相關的屬性：
-XX:MinMetaspaceFreeRatio，在GC之後，最小的Metaspace剩餘空間容量的百分比，減少為分配空間所導致的垃圾收集
-XX:MaxMetaspaceFreeRatio，在GC之後，最大的Metaspace剩餘空間容量的百分比，減少為釋放空間所導致的垃圾收集
現在我們在 JDK 8下重新執行一下程式碼段 4，不過這次不再指定 PermSize 和 MaxPermSize。而是指定 MetaSpaceSize 和 MaxMetaSpaceSize的大小。輸出結果如下：
從輸出結果，我們可以看出，這次不再出現永久代溢位，而是出現了元空間的溢位。
四、總結
通過上面分析，大家應該大致瞭解了 JVM 的記憶體劃分，也清楚了 JDK 8 中永久代向元空間的轉換。不過大家應該都有一個疑問，就是為什麼要做這個轉換？所以，最後給大家總結以下幾點原因：
1、字串存在永久代中，容易出現效能問題和記憶體溢位。
2、類及方法的資訊等比較難確定其大小，因此對於永久代的大小指定比較困難，太小容易出現永久代溢位，太大則容易導致老年代溢位。
3、永久代會為 GC 帶來不必要的複雜度，並且回收效率偏低。
4、Oracle 可能會將HotSpot 與 JRockit 合二為一。