Java 內存區域詳解

常見面試題

基本問題

  • 介紹下 Java 內存區域(運行時數據區)
  • Java 對象的創建過程(五步,建議能默寫出來並且要知道每一步虛擬機做了什麼)
  • 對象的訪問定位的兩種方式(句柄和直接指針兩種方式)

拓展問題

  • String 類和常量池
  • 8 種基本類型的包裝類和常量池

一 概述

對於 Java 程序員來說,在虛擬機自動內存管理機制下,不再需要像 C/C++程序開發程序員這樣爲每一個 new 操作去寫對應的 delete/free 操作,不容易出現內存泄漏和內存溢出問題。正是因爲 Java 程序員把內存控制權利交給 Java 虛擬機,一旦出現內存泄漏和溢出方面的問題,如果不瞭解虛擬機是怎樣使用內存的,那麼排查錯誤將會是一個非常艱鉅的任務。

二 運行時數據區域

Java 虛擬機在執行 Java 程序的過程中會把它管理的內存劃分成若干個不同的數據區域。JDK. 1.8 和之前的版本略有不同,下面會介紹到。

JDK 1.8 之前:
在這裏插入圖片描述
JDK 1.8 :
在這裏插入圖片描述

線程私有的:

  • 程序計數器
  • 虛擬機棧
  • 本地方法棧

線程共享的:

  • 方法區
  • 直接內存 (非運行時數據區的一部分)

2.1 程序計數器

程序計數器是一塊較小的內存空間,可以看作是當前線程所執行的字節碼的行號指示器。字節碼解釋器工作時通過改變這個計數器的值來選取下一條需要執行的字節碼指令,分支、循環、跳轉、異常處理、線程恢復等功能都需要依賴這個計數器來完成。

另外,爲了線程切換後能恢復到正確的執行位置,每條線程都需要有一個獨立的程序計數器,各線程之間計數器互不影響,獨立存儲,我們稱這類內存區域爲“線程私有”的內存。

從上面的介紹中我們知道程序計數器主要有兩個作用:

  1. 字節碼解釋器通過改變程序計數器來依次讀取指令,從而實現代碼的流程控制,如:順序執行、選擇、循環、異常處理。
  2. 在多線程的情況下,程序計數器用於記錄當前線程執行的位置,從而當線程被切換回來的時候能夠知道該線程上次運行到哪兒了。

注意:程序計數器是唯一一個不會出現 OutOfMemoryError 的內存區域,它的生命週期隨着線程的創建而創建,隨着線程的結束而死亡。

2.2 Java 虛擬機棧

與程序計數器一樣,Java 虛擬機棧也是線程私有的,它的生命週期和線程相同,描述的是 Java 方法執行的內存模型,每次方法調用的數據都是通過棧傳遞的。

Java 內存可以粗糙的區分爲堆內存(Heap)和棧內存 (Stack),其中棧就是現在說的虛擬機棧,或者說是虛擬機棧中局部變量表部分。 (實際上,Java 虛擬機棧是由一個個棧幀組成,而每個棧幀中都擁有:局部變量表、操作數棧、動態鏈接、方法出口信息。)

局部變量表主要存放了編譯器可知的各種數據類型(boolean、byte、char、short、int、float、long、double)、對象引用(reference 類型,它不同於對象本身,可能是一個指向對象起始地址的引用指針,也可能是指向一個代表對象的句柄或其他與此對象相關的位置)。

Java 虛擬機棧會出現兩種錯誤:StackOverFlowError 和 OutOfMemoryError。

  • StackOverFlowError: 若 Java 虛擬機棧的內存大小不允許動態擴展,那麼當線程請求棧的深度超過當前 Java 虛擬機棧的最大深度的時候,就拋出 StackOverFlowError 錯誤。
  • OutOfMemoryError: 若 Java 虛擬機棧的內存大小允許動態擴展,且當線程請求棧時內存用完了,無法再動態擴展了,此時拋出 OutOfMemoryError 錯誤。

Java 虛擬機棧也是線程私有的,每個線程都有各自的 Java 虛擬機棧,而且隨着線程的創建而創建,隨着線程的死亡而死亡。

擴展:那麼方法/函數如何調用?

Java 棧可用類比數據結構中棧,Java 棧中保存的主要內容是棧幀,每一次函數調用都會有一個對應的棧幀被壓入 Java 棧,每一個函數調用結束後,都會有一個棧幀被彈出。

Java 方法有兩種返回方式:

  1. return 語句。
  2. 拋出異常。

不管哪種返回方式都會導致棧幀被彈出。

2.3 本地方法棧

和虛擬機棧所發揮的作用非常相似,區別是: 虛擬機棧爲虛擬機執行 Java 方法 (也就是字節碼)服務,而本地方法棧則爲虛擬機使用到的 Native 方法服務。 在 HotSpot 虛擬機中和 Java 虛擬機棧合二爲一。

本地方法被執行的時候,在本地方法棧也會創建一個棧幀,用於存放該本地方法的局部變量表、操作數棧、動態鏈接、出口信息。

方法執行完畢後相應的棧幀也會出棧並釋放內存空間,也會出現 StackOverFlowError 和 OutOfMemoryError 兩種錯誤。

2.4 堆

Java 虛擬機所管理的內存中最大的一塊,Java 堆是所有線程共享的一塊內存區域,在虛擬機啓動時創建。此內存區域的唯一目的就是存放對象實例,幾乎所有的對象實例以及數組都在這裏分配內存。

Java 堆是垃圾收集器管理的主要區域,因此也被稱作GC 堆(Garbage Collected Heap).從垃圾回收的角度,由於現在收集器基本都採用分代垃圾收集算法,所以 Java 堆還可以細分爲:新生代和老年代:再細緻一點有:Eden 空間、From Survivor、To Survivor 空間等。進一步劃分的目的是更好地回收內存,或者更快地分配內存。

在 JDK 7 版本及JDK 7 版本之前,堆內存被通常被分爲下面三部分:

  1. 新生代內存(Young Generation)
  2. 老生代(Old Generation)
  3. 永生代(Permanent Generation)
    在這裏插入圖片描述
    JVM堆內存結構-JDK7

JDK 8 版本之後方法區(HotSpot 的永久代)被徹底移除了(JDK1.7 就已經開始了),取而代之是元空間,元空間使用的是直接內存。

JVM堆內存結構-JDK8

上圖所示的 Eden 區、兩個 Survivor 區都屬於新生代(爲了區分,這兩個 Survivor 區域按照順序被命名爲 from 和 to),中間一層屬於老年代。

大部分情況,對象都會首先在 Eden 區域分配,在一次新生代垃圾回收後,如果對象還存活,則會進入 s0 或者 s1,並且對象的年齡還會加 1(Eden 區->Survivor 區後對象的初始年齡變爲 1),當它的年齡增加到一定程度(默認爲 15 歲),就會被晉升到老年代中。對象晉升到老年代的年齡閾值,可以通過參數 -XX:MaxTenuringThreshold 來設置。

修正(issue552):“Hotspot遍歷所有對象時,按照年齡從小到大對其所佔用的大小進行累積,當累積的某個年齡大小超過了survivor區的一半時,取這個年齡和MaxTenuringThreshold中更小的一個值,作爲新的晉升年齡閾值”。

動態年齡計算的代碼如下

uint ageTable::compute_tenuring_threshold(size_t survivor_capacity) {
	//survivor_capacity是survivor空間的大小
size_t desired_survivor_size = (size_t)((((double) survivor_capacity)*TargetSurvivorRatio)/100);
size_t total = 0;
uint age = 1;
while (age < table_size) {
 total += sizes[age];//sizes數組是每個年齡段對象大小
 if (total > desired_survivor_size) break;
 age++;
}
uint result = age < MaxTenuringThreshold ? age : MaxTenuringThreshold;
	...
}

堆這裏最容易出現的就是 OutOfMemoryError 錯誤,並且出現這種錯誤之後的表現形式還會有幾種,比如:

  1. OutOfMemoryError: GC Overhead Limit Exceeded : 當JVM花太多時間執行垃圾回收並且只能回收很少的堆空間時,就會發生此錯誤。
  2. java.lang.OutOfMemoryError: Java heap space :假如在創建新的對象時, 堆內存中的空間不足以存放新創建的對象, 就會引發java.lang.OutOfMemoryError: Java heap space 錯誤。(和本機物理內存無關,和你配置的對內存大小有關!)

2.5 方法區

方法區與 Java 堆一樣,是各個線程共享的內存區域,它用於存儲已被虛擬機加載的類信息、常量、靜態變量、即時編譯器編譯後的代碼等數據。雖然 Java 虛擬機規範把方法區描述爲堆的一個邏輯部分,但是它卻有一個別名叫做 Non-Heap(非堆),目的應該是與 Java 堆區分開來。

方法區也被稱爲永久代。很多人都會分不清方法區和永久代的關係,爲此我也查閱了文獻。

2.5.1 方法區和永久代的關係

《Java 虛擬機規範》只是規定了有方法區這麼個概念和它的作用,並沒有規定如何去實現它。那麼,在不同的 JVM 上方法區的實現肯定是不同的了。 方法區和永久代的關係很像 Java 中接口和類的關係,類實現了接口,而永久代就是 HotSpot 虛擬機對虛擬機規範中方法區的一種實現方式。 也就是說,永久代是 HotSpot 的概念,方法區是 Java 虛擬機規範中的定義,是一種規範,而永久代是一種實現,一個是標準一個是實現,其他的虛擬機實現並沒有永久代這一說法。

2.5.2 常用參數

JDK 1.8 之前永久代還沒被徹底移除的時候通常通過下面這些參數來調節方法區大小

-XX:PermSize=N //方法區 (永久代) 初始大小
-XX:MaxPermSize=N //方法區 (永久代) 最大大小,超過這個值將會拋出 OutOfMemoryError 異常:java.lang.OutOfMemoryError: PermGen

相對而言,垃圾收集行爲在這個區域是比較少出現的,但並非數據進入方法區後就“永久存在”了。

JDK 1.8 的時候,方法區(HotSpot 的永久代)被徹底移除了(JDK1.7 就已經開始了),取而代之是元空間,元空間使用的是直接內存。

下面是一些常用參數:

-XX:MetaspaceSize=N //設置 Metaspace 的初始(和最小大小)
-XX:MaxMetaspaceSize=N //設置 Metaspace 的最大大小

與永久代很大的不同就是,如果不指定大小的話,隨着更多類的創建,虛擬機會耗盡所有可用的系統內存。

2.5.3 爲什麼要將永久代 (PermGen) 替換爲元空間 (MetaSpace) 呢?

  1. 整個永久代有一個 JVM 本身設置固定大小上限,無法進行調整,而元空間使用的是直接內存,受本機可用內存的限制,雖然元空間仍舊可能溢出,但是比原來出現的機率會更小。

當你元空間溢出時會得到如下錯誤: java.lang.OutOfMemoryError: MetaSpace

你可以使用 -XX:MaxMetaspaceSize 標誌設置最大元空間大小,默認值爲 unlimited,這意味着它只受系統內存的限制。-XX:MetaspaceSize 調整標誌定義元空間的初始大小如果未指定此標誌,則 Metaspace 將根據運行時的應用程序需求動態地重新調整大小。

  1. 元空間裏面存放的是類的元數據,這樣加載多少類的元數據就不由 MaxPermSize 控制了, 而由系統的實際可用空間來控制,這樣能加載的類就更多了。

  2. 在 JDK8,合併 HotSpot 和 JRockit 的代碼時, JRockit 從來沒有一個叫永久代的東西, 合併之後就沒有必要額外的設置這麼一個永久代的地方了。

2.6 運行時常量池

運行時常量池是方法區的一部分。Class 文件中除了有類的版本、字段、方法、接口等描述信息外,還有常量池信息(用於存放編譯期生成的各種字面量和符號引用)

既然運行時常量池是方法區的一部分,自然受到方法區內存的限制,當常量池無法再申請到內存時會拋出 OutOfMemoryError 錯誤。

JDK1.7 及之後版本的 JVM 已經將運行時常量池從方法區中移了出來,在 Java 堆(Heap)中開闢了一塊區域存放運行時常量池。
在這裏插入圖片描述
——圖片來源:https://blog.csdn.net/wangbiao007/article/details/78545189

2.7 直接內存

直接內存並不是虛擬機運行時數據區的一部分,也不是虛擬機規範中定義的內存區域,但是這部分內存也被頻繁地使用。而且也可能導致 OutOfMemoryError 錯誤出現。

JDK1.4 中新加入的 NIO(New Input/Output) 類,引入了一種基於通道(Channel)緩存區(Buffer) 的 I/O 方式,它可以直接使用 Native 函數庫直接分配堆外內存,然後通過一個存儲在 Java 堆中的 DirectByteBuffer 對象作爲這塊內存的引用進行操作。這樣就能在一些場景中顯著提高性能,因爲避免了在 Java 堆和 Native 堆之間來回複製數據

本機直接內存的分配不會受到 Java 堆的限制,但是,既然是內存就會受到本機總內存大小以及處理器尋址空間的限制。

三 HotSpot 虛擬機對象探祕

通過上面的介紹我們大概知道了虛擬機的內存情況,下面我們來詳細的瞭解一下 HotSpot 虛擬機在 Java 堆中對象分配、佈局和訪問的全過程。

3.1 對象的創建

下圖便是 Java 對象的創建過程,我建議最好是能默寫出來,並且要掌握每一步在做什麼。
在這裏插入圖片描述

Step1:類加載檢查

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

Step2:分配內存

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

內存分配的兩種方式:(補充內容,需要掌握)

選擇以上兩種方式中的哪一種,取決於 Java 堆內存是否規整。而 Java 堆內存是否規整,取決於 GC 收集器的算法是"標記-清除",還是"標記-整理"(也稱作"標記-壓縮"),值得注意的是,複製算法內存也是規整的

在這裏插入圖片描述

內存分配併發問題(補充內容,需要掌握)

在創建對象的時候有一個很重要的問題,就是線程安全,因爲在實際開發過程中,創建對象是很頻繁的事情,作爲虛擬機來說,必須要保證線程是安全的,通常來講,虛擬機採用兩種方式來保證線程安全:

  • CAS+失敗重試: CAS 是樂觀鎖的一種實現方式。所謂樂觀鎖就是,每次不加鎖而是假設沒有衝突而去完成某項操作,如果因爲衝突失敗就重試,直到成功爲止。虛擬機採用 CAS 配上失敗重試的方式保證更新操作的原子性。
  • TLAB: 爲每一個線程預先在 Eden 區分配一塊兒內存,JVM 在給線程中的對象分配內存時,首先在 TLAB 分配,當對象大於 TLAB 中的剩餘內存或 TLAB 的內存已用盡時,再採用上述的 CAS 進行內存分配

Step3:初始化零值

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

Step4:設置對象頭

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

Step5:執行 init 方法

在上面工作都完成之後,從虛擬機的視角來看,一個新的對象已經產生了,但從 Java 程序的視角來看,對象創建纔剛開始,<init> 方法還沒有執行,所有的字段都還爲零。所以一般來說,執行 new 指令之後會接着執行 <init> 方法,把對象按照程序員的意願進行初始化,這樣一個真正可用的對象纔算完全產生出來。

3.2 對象的內存佈局

在 Hotspot 虛擬機中,對象在內存中的佈局可以分爲 3 塊區域:對象頭實例數據對齊填充

Hotspot 虛擬機的對象頭包括兩部分信息第一部分用於存儲對象自身的自身運行時數據(哈希碼、GC 分代年齡、鎖狀態標誌等等),另一部分是類型指針,即對象指向它的類元數據的指針,虛擬機通過這個指針來確定這個對象是那個類的實例。

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

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

3.3 對象的訪問定位

建立對象就是爲了使用對象,我們的 Java 程序通過棧上的 reference 數據來操作堆上的具體對象。對象的訪問方式由虛擬機實現而定,目前主流的訪問方式有①使用句柄②直接指針兩種:

  1. 句柄: 如果使用句柄的話,那麼 Java 堆中將會劃分出一塊內存來作爲句柄池,reference 中存儲的就是對象的句柄地址,而句柄中包含了對象實例數據與類型數據各自的具體地址信息;
    在這裏插入圖片描述

  2. 直接指針: 如果使用直接指針訪問,那麼 Java 堆對象的佈局中就必須考慮如何放置訪問類型數據的相關信息,而 reference 中存儲的直接就是對象的地址。
    在這裏插入圖片描述

這兩種對象訪問方式各有優勢。使用句柄來訪問的最大好處是 reference 中存儲的是穩定的句柄地址,在對象被移動時只會改變句柄中的實例數據指針,而 reference 本身不需要修改。使用直接指針訪問方式最大的好處就是速度快,它節省了一次指針定位的時間開銷。

四 重點補充內容

4.1 String 類和常量池

String 對象的兩種創建方式:

String str1 = "abcd";//先檢查字符串常量池中有沒有"abcd",如果字符串常量池中沒有,則創建一個,然後 str1 指向字符串常量池中的對象,如果有,則直接將 str1 指向"abcd"";
String str2 = new String("abcd");//堆中創建一個新的對象
String str3 = new String("abcd");//堆中創建一個新的對象
System.out.println(str1==str2);//false
System.out.println(str2==str3);//false

這兩種不同的創建方法是有差別的。

  • 第一種方式是在常量池中拿對象;
  • 第二種方式是直接在堆內存空間創建一個新的對象。

記住一點:只要使用 new 方法,便需要創建新的對象。

再給大家一個圖應該更容易理解,圖片來源:https://www.journaldev.com/797/what-is-java-string-pool
在這裏插入圖片描述

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

  • 直接使用雙引號聲明出來的 String 對象會直接存儲在常量池中。
  • 如果不是用雙引號聲明的 String 對象,可以使用 String 提供的 intern 方法。String.intern() 是一個 Native 方法,它的作用是:如果運行時常量池中已經包含一個等於此 String 對象內容的字符串,則返回常量池中該字符串的引用;如果沒有,JDK1.7之前(不包含1.7)的處理方式是在常量池中創建與此 String 內容相同的字符串,並返回常量池中創建的字符串的引用,JDK1.7以及之後的處理方式是在常量池中記錄此字符串的引用,並返回該引用。
	      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(s3 == s2);//true,因爲兩個都是常量池中的 String 對象

在這裏插入圖片描述
字符串拼接:

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

儘量避免多個字符串拼接,因爲這樣會重新創建對象。如果需要改變字符串的話,可以使用 StringBuilder 或者 StringBuffer。

4.2 String s1 = new String(“abc”);這句話創建了幾個字符串對象?

將創建 1 或 2 個字符串。如果池中已存在字符串常量“abc”,則只會在堆空間創建一個字符串常量“abc”。如果池中沒有字符串常量“abc”,那麼它將首先在池中創建,然後在堆空間中創建,因此將創建總共 2 個字符串對象。

驗證:

		String s1 = new String("abc");// 堆內存的地址值
		String s2 = "abc";
		System.out.println(s1 == s2);// 輸出 false,因爲一個是堆內存,一個是常量池的內存,故兩者是不同的。
		System.out.println(s1.equals(s2));// 輸出 true

結果:

false
true

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

  • Java 基本類型的包裝類的大部分都實現了常量池技術,即 Byte,Short,Integer,Long,Character,Boolean;這 5 種包裝類默認創建了數值[-128,127] 的相應類型的緩存數據,但是超出此範圍仍然會去創建新的對象。 爲啥把緩存設置爲[-128,127]區間?(參見issue/461)性能和資源之間的權衡。
  • 兩種浮點數類型的包裝類 Float,Double 並沒有實現常量池技術。
		Integer i1 = 33;
		Integer i2 = 33;
		System.out.println(i1 == i2);// 輸出 true
		Integer i11 = 333;
		Integer i22 = 333;
		System.out.println(i11 == i22);// 輸出 false
		Double i3 = 1.2;
		Double i4 = 1.2;
		System.out.println(i3 == i4);// 輸出 false

Integer 緩存源代碼:

/**
*此方法將始終緩存-128 到 127(包括端點)範圍內的值,並可以緩存此範圍之外的其他值。
*/
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

應用場景:

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

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));
  System.out.println("i1=i2+i3   " + (i1 == i2 + i3));
  System.out.println("i1=i4   " + (i1 == i4));
  System.out.println("i4=i5   " + (i4 == i5));
  System.out.println("i4=i5+i6   " + (i4 == i5 + i6));   
  System.out.println("40=i5+i6   " + (40 == i5 + i6));     

結果:

i1=i2   true
i1=i2+i3   true
i1=i4   false
i4=i5   false
i4=i5+i6   true
40=i5+i6   true

解釋:

語句 i4 == i5 + i6,因爲+這個操作符不適用於 Integer 對象,首先 i5 和 i6 進行自動拆箱操作,進行數值相加,即 i4 == 40。然後 Integer 對象無法與數值進行直接比較,所以 i4 自動拆箱轉爲 int 值 40,最終這條語句轉爲 40 == 40 進行數值比較。

參考

發佈了33 篇原創文章 · 獲贊 69 · 訪問量 1621
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章