JVM運行時數據區域

1、運行時數據區域

 

• 相應腦圖

程序計數器

記錄正在執行的虛擬機字節碼指令的地址（若是正在執行的是本地方法則爲空）。

Java 虛擬機棧

每一個 Java 方法在執行的同時會建立一個棧幀用於存儲局部變量表、操做數棧、常量池引用等信息。 從方法調用直至執行完成的過程，就對應着一個棧幀在 Java 虛擬機棧中入棧和出棧的過程。 對於執行引擎來講，活動線程中，只有棧頂的棧幀是有效的，稱爲當前棧幀，這個棧幀所關聯的方法稱爲當前方法。 執行引擎所運行的全部字節碼指令都只針對當前棧幀進行操做。

 

操做數棧：
一個後進先出（Last-In-First-Out）的操做數棧，也能夠稱之爲表達式棧（Expression Stack）。
操做數棧和局部變量表在訪問方式上存在着較大差別，操做數棧並不是採用訪問索引的方式來進行數據訪問的，
而是**經過標準的入棧和出棧操做來完成一次數據訪問**。
每個操做數棧都會擁有一個明確的棧深度用於存儲數值，一個32bit的數值能夠用一個單位的棧深度來存儲，而2個單位的棧深度則能夠保存一個64bit的數值，
固然操做數棧所需的容量大小在編譯期就能夠被徹底肯定下來，並保存在方法的Code屬性中。

能夠經過 -Xss 這個虛擬機參數來指定每一個線程的 Java 虛擬機棧內存大小：

java -Xss512M HackTheJava

該區域可能拋出如下異常：

• 當線程請求的棧深度超過最大值，會拋出 StackOverflowError 異常；
• 棧進行動態擴展時若是沒法申請到足夠內存，會拋出 OutOfMemoryError 異常。

本地方法棧

本地方法棧與 Java 虛擬機棧相似，它們之間的區別只不過是本地方法棧爲本地方法服務。

本地方法通常是用其它語言（C、C++ 或彙編語言等）編寫的，而且被編譯爲基於本機硬件和操做系統的程序，對待這些方法須要特別處理。

 

堆

全部對象都在這裏分配內存，是垃圾收集的主要區域（"GC 堆"）。

現代的垃圾收集器基本都是採用分代收集算法，其主要的思想是針對不一樣類型的對象採起不一樣的垃圾回收算法，能夠將堆分紅兩塊：

• 新生代（Young Generation）
• 老年代（Old Generation）

堆不須要連續內存，而且能夠動態增長其內存，增長失敗會拋出 OutOfMemoryError 異常。

能夠經過 -Xms 和 -Xmx 兩個虛擬機參數來指定一個程序的堆內存大小，第一個參數設置初始值，第二個參數設置最大值。

java -Xms1M -Xmx2M HackTheJava

 

方法區

用於存放已被加載的類信息、常量、靜態變量、即時編譯器編譯後的代碼等數據。

和堆同樣不須要連續的內存，而且能夠動態擴展，動態擴展失敗同樣會拋出 OutOfMemoryError 異常。

對這塊區域進行垃圾回收的主要目標是對常量池的回收和對類的卸載，可是通常比較難實現。

HotSpot 虛擬機把它當成永久代來進行垃圾回收。可是很難肯定永久代的大小，由於它受到不少因素影響，而且每次 Full GC 以後永久代的大小都會改變，因此常常會拋出 OutOfMemoryError 異常。爲了更容易管理方法區，從 JDK 1.8 開始，移除永久代，並把方法區移至元空間，它位於本地內存中，而不是虛擬機內存中。

運行時常量池

運行時常量池是方法區的一部分。

Class 文件中的常量池（編譯器生成的各類字面量和符號引用）會在類加載後被放入這個區域。

除了在編譯期生成的常量，還容許動態生成，例如 String 類的 intern()。

直接內存

在 JDK 1.4 中新加入了 NIO 類，它可使用 Native 函數庫直接分配堆外內存（Native 堆），而後經過一個存儲在 Java 堆裏的 DirectByteBuffer 對象做爲這塊內存的引用進行操做。

這樣能在一些場景中顯著提升性能，由於避免了在 Java 堆和 Native 堆中來回複製數據。

2、HotSpot虛擬機對象

對象的建立

對象的建立步驟：

 

1. 類加載檢查

虛擬機遇到一條 new 指令時，首先將去檢查這個指令的參數是否能在常量池中定位到這個類的符號引用， 而且檢查這個符號引用表明的類是否已被加載過、解析和初始化過。 若是沒有，那必須先執行相應的類加載過程。

1. 分配內存

在類加載檢查經過後，接下來虛擬機將爲新生對象分配內存。 對象所需的內存大小在類加載完成後即可肯定，爲對象分配空間的任務等同於把一塊肯定大小的內存從 Java 堆中劃分出來。分配方式有 「指針碰撞」 和 「空閒列表」 兩種，選擇那種分配方式由 Java 堆是否規整決定， 而Java堆是否規整又由所採用的垃圾收集器是否帶有壓縮整理功能決定。

• 內存分配的兩種方式

內存分配的兩種方式	指針碰撞	空閒列表
適用場景	堆內存規整(即沒有內存碎片)的狀況	堆內存不規整的狀況
原理	用過的內存所有整合到一邊，沒有用過的內存放在另外一邊，中間有一個分界值指針，只須要向着沒用過的內存方向將指針移動一段與對象大小相等的距離	虛擬機會維護一個列表，在該列表和總分記錄哪些內存塊是可用的，在分配的時候，找一塊足夠大的內存塊劃分給對象示例，而後更新列表記錄
GC收集器	Serial ParNew	CMS

• 內存分配併發問題

在建立對象的時候有一個很重要的問題，就是線程安全，由於在實際開發過程當中，建立對象是很頻繁的事情， 做爲虛擬機來講，必需要保證線程是安全的，一般來說，虛擬機採用兩種方式來保證線程安全：

(1)CAS+失敗重試： CAS 是樂觀鎖的一種實現方式。所謂樂觀鎖就是， 每次不加鎖而是假設沒有衝突而去完成某項操做， 若是由於衝突失敗就重試，直到成功爲止。 虛擬機採用CAS配上失敗重試的方式保證更新操做的原子性。

(2)TLAB: 每個線程預先在Java堆中分配一塊內存，稱爲本地線程分配緩衝(Thread Local Allocation Buffer,TLAB)。 哪一個線程要分配內存，就在哪一個線程的TLAB上分配，只有TLAB用完並分配新的TLAB時，才採用上述的CAS進行內存分配。

1. 初始化零值

內存分配完成後，虛擬機須要將分配到的內存空間都初始化爲零值（不包括對象頭）， 這一步操做保證了對象的實例字段在 Java 代碼中能夠不賦初始值就直接使用， 程序能訪問到這些字段的數據類型所對應的零值。

1. 設置對象頭

初始化零值完成以後，虛擬機要對對象進行必要的設置， 例如這個對象是那個類的實例、如何才能找到類的元數據信息、對象的哈希嗎、對象的 GC 分代年齡等信息。 這些信息存放在對象頭中。 另外，根據虛擬機當前運行狀態的不一樣，如是否啓用偏向鎖等，對象頭會有不一樣的設置方式。

1. 執行init方法

在上面工做都完成以後，從虛擬機的視角來看，一個新的對象已經產生了， 但從 Java 程序的視角來看，對象建立纔剛開始，<init> 方法尚未執行，全部的字段都還爲零。 因此通常來講，執行 new 指令以後會接着執行 <init > 方法， 把對象按照程序員的意願進行初始化，這樣一個真正可用的對象纔算徹底產生出來。

對象的內存佈局

在 Hotspot 虛擬機中，對象在內存中的佈局能夠分爲3塊區域：

(1)對象頭

(2)實例數據

(3)對齊填充

1. 對象頭

Hotspot虛擬機的對象頭包括兩部分信息：

一部分用於存儲對象自身的運行時數據（哈希碼、GC分代年齡、鎖狀態標誌等等），

另外一部分是類型指針，即對象指向它的類元數據的指針，虛擬機經過這個指針來肯定這個對象是那個類的實例。

1. 實例數據

實例數據部分是對象真正存儲的有效信息，也是在程序中所定義的各類類型的字段內容。

1. 對齊填充

對齊填充部分不是必然存在的，也沒有什麼特別的含義，僅僅起佔位做用。 由於Hotspot虛擬機的自動內存管理系統要求對象起始地址必須是8字節的整數倍， 換句話說就是對象的大小必須是8字節的整數倍。而對象頭部分正好是8字節的倍數（1倍或2倍）， 所以，當對象實例數據部分沒有對齊時，就須要經過對齊填充來補全。

對象的訪問定位

創建對象就是爲了使用對象，咱們的Java程序經過棧上的 reference 數據來操做堆上的具體對象。 對象的訪問方式視虛擬機的實現而定，目前主流的訪問方式有兩種：

(1)使用句柄

(2)直接指針

1. 使用句柄

若是使用句柄的話，那麼Java堆中將會劃分出一塊內存來做爲句柄池， reference中存儲的就是對象的句柄地址，而句柄中包含了對象實例數據與類型數據各自的具體地址信息

 

1. 直接指針

若是使用直接指針訪問，那麼Java 堆對象的佈局中就必須考慮如何放置訪問類型數據的相關信息， 而reference中存儲的直接就是對象的地址。

 

這兩種對象訪問方式各有優點:

(1)使用句柄來訪問的最大好處是 reference 中存儲的是穩定的句柄地址， 在對象被移動時只會改變句柄中的實例數據指針，而reference自己不須要修改。

(2)使用直接指針訪問方式最大的好處就是速度快，它節省了一次指針定位的時間開銷。

3、String類和常量池

1. String對象的兩種建立方式

String str1 = "abcd";
String str2 = new String("abcd");
System.out.println(str1==str2);//false

這兩種不一樣的建立方法是有差異的:

第一種方式是在常量池中獲取對象("abcd" 屬於字符串字面量，所以編譯時期會在常量池中建立一個字符串對象)，

第二種方式一共會建立兩個字符串對象（前提是 String Pool 中尚未 "abcd" 字符串對象）。

• "abcd" 屬於字符串字面量，所以編譯時期會在常量池中建立一個字符串對象，指向這個 "abcd" 字符串字面量；

• 使用 new 的方式會在堆中建立一個字符串對象。

 

1. String類型的常量池比較特殊。它的主要使用方法有兩種：

• 直接使用雙引號聲明出來的String對象會直接存儲在常量池中。

• 若是不是用雙引號聲明的String對象,可使用 String 提供的 intern 方法。 String.intern() 是一個 Native 方法，它的做用是： 若是運行時常量池中已經包含一個等於此 String 對象內容的字符串，則返回常量池中該字符串的引用； 若是沒有，則在常量池中建立與此 String 內容相同的字符串，並返回常量池中建立的字符串的引用。

String s1 = new String("計算機");
String s2 = s1.intern();
String s3 = "計算機";
System.out.println(s2);//計算機
System.out.println(s1 == s2);//false，由於一個是堆內存中的String對象一個是常量池中的String對象，
System.out.println(s2 == s3);//true，由於兩個都是常量池中的String對象

1. 字符串拼接：

String str1 = "str";
String str2 = "ing";
		  
String str3 = "str" + "ing";//常量池中的對象
String str4 = str1 + str2; //TODO:在堆上建立的新的對象	  
String str5 = "string";//常量池中的對象
System.out.println(str3 == str4);//false
System.out.println(str3 == str5);//true
System.out.println(str4 == str5);//false

 

注意：儘可能避免多個字符串拼接，由於這樣會從新建立對象。 若是須要改變字符串的話，可使用 StringBuilder 或者 StringBuffer。

面試題：String s1 = new String("abc");問建立了幾個對象？

建立2個字符串對象（前提是 String Pool 中尚未 "abcd" 字符串對象）。

• "abc" 屬於字符串字面量，所以編譯時期會在常量池中建立一個字符串對象，指向這個 "abcd" 字符串字面量；

• 使用 new 的方式會在堆中建立一個字符串對象。

(字符串常量"abc"在編譯期就已經肯定放入常量池，而 Java 堆上的"abc"是在運行期初始化階段才肯定)。

String s1 = new String("abc");// 堆內存的地址值
String s2 = "abc";
System.out.println(s1 == s2);// 輸出false
//由於一個是堆內存，一個是常量池的內存，故二者是不一樣的。
System.out.println(s1.equals(s2));// 輸出true

4、8種基本類型的包裝類和常量池

• Java基本類型的包裝類的大部分都實現了常量池技術， 即Byte,Short,Integer,Long,Character,Boolean； 這5種包裝類默認建立了數值**[-128，127]**的相應類型的緩存數據， 可是超出此範圍仍然會去建立新的對象。

• 兩種浮點數類型的包裝類Float,Double 並無實現常量池技術。

valueOf() 方法的實現比較簡單，就是先判斷值是否在緩存池中，若是在的話就直接返回緩存池的內容。

Integer的部分源碼：

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

在 Java 8 中，Integer 緩存池的大小默認爲 -128~127。

static final int low = -128;
static final int high;
static final Integer cache[];

static {
    // high value may be configured by property
    int h = 127;
    String integerCacheHighPropValue =
        sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
    if (integerCacheHighPropValue != null) {
        try {
            int i = parseInt(integerCacheHighPropValue);
            i = Math.max(i, 127);
            // Maximum array size is Integer.MAX_VALUE
            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
        } catch( NumberFormatException nfe) {
            // If the property cannot be parsed into an int, ignore it.
        }
    }
    high = h;

    cache = new Integer[(high - low) + 1];
    int j = low;
    for(int k = 0; k < cache.length; k++)
        cache[k] = new Integer(j++);

    // range [-128, 127] must be interned (JLS7 5.1.7)
    assert IntegerCache.high >= 127;
}

• 示例1:

Integer i1=40;
//Java 在編譯的時候會直接將代碼封裝成 Integer i1=Integer.valueOf(40);從而使用常量池中的對象。
Integer i2 = new Integer(40);
//建立新的對象。
System.out.println(i1==i2);//輸出false

• 示例2：Integer有自動拆裝箱功能

Integer i1 = 40;
Integer i2 = 40;
Integer i3 = 0;
Integer i4 = new Integer(40);
Integer i5 = new Integer(40);
Integer i6 = new Integer(0);
  
System.out.println("i1=i2   " + (i1 == i2)); //輸出 i1=i2  true
System.out.println("i1=i2+i3   " + (i1 == i2 + i3)); //輸出 i1=i2+i3  true
//i2+i3獲得40,比較的是數值
System.out.println("i1=i4   " + (i1 == i4)); //輸出 i1=i4 false
System.out.println("i4=i5   " + (i4 == i5)); //輸出 i4=i5 false
//i5+i6獲得40，比較的是數值
System.out.println("i4=i5+i6   " + (i4 == i5 + i6)); //輸出 i4=i5+i6 true
System.out.println("40=i5+i6   " + (40 == i5 + i6)); //輸出 40=i5+i6 true