（2020史上最全總結，跳槽必看）Java虛擬機（JVM）面試題

Java內存模型

咱們開發人員編寫的Java代碼是怎麼讓電腦認識的

1. 首先先了解電腦是二進制的系統，他只認識 01010101
2. 好比咱們常常要編寫 HelloWord.java 電腦是怎麼認識運行的
3. HelloWord.java是咱們程序員編寫的，咱們人能夠認識，可是電腦不認識

Java文件編譯的過程

1. 程序員編寫的.java文件
2. 由javac編譯成字節碼文件.class：（爲何編譯成class文件，由於JVM只認識.class文件）
3. 在由JVM編譯成電腦認識的文件 （對於電腦系統來講 文件表明一切）

（這是一個大概的觀念 抽象畫的概念）

爲何說java是跨平臺語言

• 這個誇平臺是中間語言（JVM）實現的誇平臺
• Java有JVM從軟件層面屏蔽了底層硬件、指令層面的細節讓他兼容各類系統

難道 C 和 C++ 不能誇平臺嗎 其實也能夠
C和C++須要在編譯器層面去兼容不一樣操做系統的不一樣層面，寫過C和C++的就知道不一樣操做系統的有些代碼是不同

Jdk和Jre和JVM的區別

• Jdk包括了Jre和Jvm，Jre包括了Jvm
• Jdk是咱們編寫代碼使用的開發工具包
• Jre 是Java的運行時環境，他大部分都是 C 和 C++ 語言編寫的，他是咱們在編譯java時所須要的基礎的類庫
• Jvm俗稱Java虛擬機，他是java運行環境的一部分，它虛構出來的一臺計算機，在經過在實際的計算機上仿真模擬各類計算機功能來實現Java應用程序

看Java官方的圖片，Jdk中包括了Jre，Jre中包括了JVM

說一下 JVM由那些部分組成，運行流程是什麼？

JVM包含兩個子系統和兩個組件:

兩個子系統爲Class loader(類裝載)、Execution engine(執行引擎)；
兩個組件爲Runtime data area(運行時數據區)、Native Interface(本地接口)。

• Class loader(類裝載)：根據給定的全限定名類名(如：java.lang.Object)來裝載class文件到Runtime data area中的method area。
• Execution engine（執行引擎）：執行classes中的指令。
• Native Interface(本地接口)：與native libraries交互，是其它編程語言交互的接口。
• Runtime data area(運行時數據區域)：這就是咱們常說的JVM的內存。

流程 ：首先經過編譯器把 Java 代碼轉換成字節碼，類加載器（ClassLoader）再把字節碼加載到內存中，將其放在運行時數據區（Runtime data area）的方法區內，而字節碼文件只是 JVM 的一套指令集規範，並不能直接交給底層操做系統去執行，所以須要特定的命令解析器執行引擎（Execution Engine），將字節碼翻譯成底層系統指令，再交由 CPU 去執行，而這個過程當中須要調用其餘語言的本地庫接口（Native Interface）來實現整個程序的功能。

說一下 JVM 運行時數據區

Java 虛擬機在執行 Java 程序的過程當中會把它所管理的內存區域劃分爲若干個不一樣的數據區域。這些區域都有各自的用途，以及建立和銷燬的時間，有些區域隨着虛擬機進程的啓動而存在，有些區域則是依賴線程的啓動和結束而創建和銷燬。Java 虛擬機所管理的內存被劃分爲以下幾個區域：

簡單的說就是咱們java運行時的東西是放在那裏的

程序計數器（Program Counter Register）：當前線程所執行的字節碼的行號指示器，字節碼解析器的工做是經過改變這個計數器的值，來選取下一條須要執行的字節碼指令，分支、循環、跳轉、異常處理、線程恢復等基礎功能，都須要依賴這個計數器來完成；

爲何要線程計數器？由於線程是不具有記憶功能

Java 虛擬機棧（Java Virtual Machine Stacks）：每一個方法在執行的同時都會在Java 虛擬機棧中建立一個棧幀（Stack Frame）用於存儲局部變量表、操做數棧、動態連接、方法出口等信息；

棧幀就是Java虛擬機棧中的下一個單位

本地方法棧（Native Method Stack）：與虛擬機棧的做用是同樣的，只不過虛擬機棧是服務 Java 方法的，而本地方法棧是爲虛擬機調用 Native 方法服務的；

Native 關鍵字修飾的方法是看不到的，Native 方法的源碼大部分都是 C和C++ 的代碼

Java 堆（Java Heap）：Java 虛擬機中內存最大的一塊，是被全部線程共享的，幾乎全部的對象實例都在這裏分配內存；

方法區（Methed Area）：用於存儲已被虛擬機加載的類信息、常量、靜態變量、即時編譯後的代碼等數據。

後面有詳細的說明JVM 運行時數據區

詳細的介紹下程序計數器？（重點理解）

程序計數器是一塊較小的內存空間，它能夠看做是：保存當前線程所正在執行的字節碼指令的地址(行號)

因爲Java虛擬機的多線程是經過線程輪流切換並分配處理器執行時間的方式來實現的，一個處理器都只會執行一條線程中的指令。所以，爲了線程切換後能恢復到正確的執行位置，每條線程都有一個獨立的程序計數器，各個線程之間計數器互不影響，獨立存儲。稱之爲「線程私有」的內存。程序計數器內存區域是虛擬機中惟一沒有規定OutOfMemoryError狀況的區域。

總結：也能夠把它叫作線程計數器

例子：在java中最小的執行單位是線程，線程是要執行指令的，執行的指令最終操做的就是咱們的電腦，就是 CPU。在CPU上面去運行，有個很是不穩定的因素，叫作調度策略，這個調度策略是時基於時間片的，也就是當前的這一納秒是分配給那個指令的。

假如：

線程A在看直播

忽然，線程B來了一個視頻電話，就會搶奪線程A的時間片，就會打斷了線程A，線程A就會掛起

而後，視頻電話結束，這時線程A究竟該幹什麼？
（線程是最小的執行單位，他不具有記憶功能，他只負責去幹，那這個記憶就由：程序計數器來記錄）

詳細介紹下Java虛擬機棧?（重點理解）

Java虛擬機是線程私有的，它的生命週期和線程相同。

虛擬機棧描述的是Java方法執行的內存模型：每一個方法在執行的同時都會建立一個棧幀（Stack Frame）用於存儲局部變量表、操做數棧、動態連接、方法出口等信息。

解釋：虛擬機棧中是有單位的，單位就是棧幀，一個方法一個棧幀。一個棧幀中他又要存儲，局部變量，操做數棧，動態連接，出口等。

解析棧幀：

局部變量表：是用來存儲咱們臨時8個基本數據類型、對象引用地址、returnAddress類型。（returnAddress中保存的是return後要執行的字節碼的指令地址。）

操做數棧：操做數棧就是用來操做的，例如代碼中有個 i = 6*6，他在一開始的時候就會進行操做，讀取咱們的代碼，進行計算後再放入局部變量表中去

動態連接：假如我方法中，有個 service.add()方法，要連接到別的方法中去，這就是動態連接，存儲連接的地方。
出口：出口是什呢，出口正常的話就是return 不正常的話就是拋出異常落

一個方法調用另外一個方法，會建立不少棧幀嗎？

答：會建立。若是一個棧中有動態連接調用別的方法，就會去建立新的棧幀，棧中是由順序的，一個棧幀調用另外一個棧幀，另外一個棧幀就會排在調用者下面

棧指向堆是什麼意思？

棧指向堆是什麼意思，就是棧中要使用成員變量怎麼辦，棧中不會存儲成員變量，只會存儲一個應用地址

遞歸的調用本身會建立不少棧幀嗎？

答：遞歸的話也會建立多個棧幀，就是在棧中一直從上往下排下去

你能給我詳細的介紹Java堆嗎?（重點理解）

java堆（Java Heap）是java虛擬機所管理的內存中最大的一塊，是被全部線程共享的一塊內存區域，在虛擬機啓動時建立。此內存區域的惟一目的就是存放對象實例。

在Java虛擬機規範中的描述是：全部的對象實例以及數組都要在堆上分配。

java堆是垃圾收集器管理的主要區域，所以也被成爲「GC堆」。

從內存回收角度來看java堆可分爲：新生代和老生代。

從內存分配的角度看，線程共享的Java堆中可能劃分出多個線程私有的分配緩衝區。

不管怎麼劃分，都與存放內容無關，不管哪一個區域，存儲的都是對象實例，進一步的劃分都是爲了更好的回收內存，或者更快的分配內存。
根據Java虛擬機規範的規定，java堆能夠處於物理上不連續的內存空間中。當前主流的虛擬機都是可擴展的（經過 -Xmx 和 -Xms 控制）。若是堆中沒有內存能夠完成實例分配，而且堆也沒法再擴展時，將會拋出OutOfMemoryError異常。

能不能解釋一下本地方法棧？

本地方法棧很好理解，他很棧很像，只不過方法上帶了 native 關鍵字的棧字

它是虛擬機棧爲虛擬機執行Java方法（也就是字節碼）的服務方法
native關鍵字的方法是看不到的，必需要去oracle官網去下載才能夠看的到，並且native關鍵字修飾的大部分源碼都是C和C++的代碼。

同理可得，本地方法棧中就是C和C++的代碼

能不能解釋一下方法區（重點理解）

方法區是全部線程共享的內存區域，它用於存儲已被Java虛擬機加載的類信息、常量、靜態變量、即時編譯器編譯後的代碼等數據。

它有個別命叫Non-Heap（非堆）。當方法區沒法知足內存分配需求時，拋出OutOfMemoryError異常。

什麼是JVM字節碼執行引擎

虛擬機核心的組件就是執行引擎，它負責執行虛擬機的字節碼，通常戶先進行編譯成機器碼後執行。

「虛擬機」是一個相對於「物理機」的概念，虛擬機的字節碼是不能直接在物理機上運行的，須要JVM字節碼執行引擎- 編譯成機器碼後纔可在物理機上執行。

你聽過直接內存嗎？

直接內存（Direct Memory）並非虛擬機運行時數據區的一部分，也不是Java虛擬機中定義的內存區域。可是這部份內存也被頻繁地使用，並且也可能致使 OutOfMemoryError 異常出現，因此咱們放到這裏一塊兒講解。

個人理解就是直接內存是基於物理內存和Java虛擬機內存的中間內存

知道垃圾收集系統嗎？

程序在運行過程當中，會產生大量的內存垃圾（一些沒有引用指向的內存對象都屬於內存垃圾，由於這些對象已經沒法訪問，程序用不了它們了，對程序而言它們已經死亡），爲了確保程序運行時的性能，java虛擬機在程序運行的過程當中不斷地進行自動的垃圾回收（GC）。

垃圾收集系統是Java的核心，也是不可少的，Java有一套本身進行垃圾清理的機制，開發人員無需手工清理

有一部分緣由就是由於Java垃圾回收系統的強大致使Java領先市場

堆棧的區別是什麼？

注意：

靜態變量放在方法區

靜態的對象仍是放在堆。

深拷貝和淺拷貝

淺拷貝（shallowCopy）只是增長了一個指針指向已存在的內存地址。

深拷貝（deepCopy）是增長了一個指針而且申請了一個新的內存，使這個增長的指針指向這個新的內存，

淺複製：僅僅是指向被複制的內存地址，若是原地址發生改變，那麼淺複製出來的對象也會相應的改變。

深複製：在計算機中開闢一塊新的內存地址用於存放複製的對象。

Java會存在內存泄漏嗎？請說明爲何？

內存泄漏是指再也不被使用的對象或者變量一直被佔據在內存中。理論上來講，Java是有GC垃圾回收機制的，也就是說，再也不被使用的對象，會被GC自動回收掉，自動從內存中清除。

可是，即便這樣，Java也仍是存在着內存泄漏的狀況，java致使內存泄露的緣由很明確：長生命週期的對象持有短生命週期對象的引用就極可能發生內存泄露，儘管短生命週期對象已經再也不須要，可是由於長生命週期對象持有它的引用而致使不能被回收，這就是java中內存泄露的發生場景。

垃圾回收機制及算法

簡述Java垃圾回收機制

在java中，程序員是不須要顯示的去釋放一個對象的內存的，而是由虛擬機自行執行。在JVM中，有一個垃圾回收線程，它是低優先級的，在正常狀況下是不會執行的，只有在虛擬機空閒或者當前堆內存不足時，纔會觸發執行，掃面那些沒有被任何引用的對象，並將它們添加到要回收的集合中，進行回收。

GC是什麼？爲何要GC

GC 是垃圾收集的意思（Gabage Collection）,內存處理是編程人員容易出現問題的地方，忘記或者錯誤的內存回收會致使程序或系統的不穩定甚至崩潰，Java 提供的 GC 功能能夠自動監測對象是否超過做用域從而達到自動回收內存的目的，Java 語言沒有提供釋放已分配內存的顯示操做方法。

垃圾回收的優勢和缺點

優勢：JVM的垃圾回收器都不須要咱們手動處理無引用的對象了，這個就是最大的優勢

缺點：程序員不能實時的對某個對象或全部對象調用垃圾回收器進行垃圾回收。

垃圾回收器的原理是什麼？有什麼辦法手動進行垃圾回收？

對於GC來講，當程序員建立對象時，GC就開始監控這個對象的地址、大小以及使用狀況。

一般，GC採用有向圖的方式記錄和管理堆(heap)中的全部對象。經過這種方式肯定哪些對象是"可達的"，哪些對象是"不可達的"。當GC肯定一些對象爲"不可達"時，GC就有責任回收這些內存空間。

能夠。程序員能夠手動執行System.gc()，通知GC運行，可是Java語言規範並不保證GC必定會執行。

JVM 中都有哪些引用類型？

強引用：發生 gc 的時候不會被回收。
軟引用：有用但不是必須的對象，在發生內存溢出以前會被回收。
弱引用：有用但不是必須的對象，在下一次GC時會被回收。
虛引用（幽靈引用/幻影引用）：沒法經過虛引用得到對象，用 PhantomReference 實現虛引用，虛引用的用途是在 gc 時返回一個通知。

怎麼判斷對象是否能夠被回收？

垃圾收集器在作垃圾回收的時候，首先須要斷定的就是哪些內存是須要被回收的，哪些對象是存活的，是不能夠被回收的；哪些對象已經死掉了，須要被回收。

通常有兩種方法來判斷：

引用計數器法：爲每一個對象建立一個引用計數，有對象引用時計數器 +1，引用被釋放時計數 -1，當計數器爲 0 時就能夠被回收。它有一個缺點不能解決循環引用的問題；（這個已經淘汰了）

可達性分析算法：從 GC Roots 開始向下搜索，搜索所走過的路徑稱爲引用鏈。當一個對象到 GC Roots 沒有任何引用鏈相連時，則證實此對象是能夠被回收的。（市場上用的很是很是普遍）

Full GC是什麼

清理整個堆空間—包括年輕代和老年代和永久代
由於Full GC是清理整個堆空間因此Full GC執行速度很是慢，在Java開發中最好保證少觸發Full GC

對象何時能夠被垃圾器回收

當對象對當前使用這個對象的應用程序變得不可觸及的時候，這個對象就能夠被回收了。

垃圾回收不會發生在永久代，若是永久代滿了或者是超過了臨界值，會觸發徹底垃圾回收(Full GC)。若是你仔細查看垃圾收集器的輸出信息，就會發現永久代也是被回收的。這就是爲何正確的永久代大小對避免Full GC是很是重要的緣由。

JVM 垃圾回收算法有哪些？

標記-清除算法：標記無用對象，而後進行清除回收。缺點：效率不高，沒法清除垃圾碎片。

複製算法：按照容量劃分二個大小相等的內存區域，當一塊用完的時候將活着的對象複製到另外一塊上，而後再把已使用的內存空間一次清理掉。缺點：內存使用率不高，只有原來的一半。

標記-整理算法：標記無用對象，讓全部存活的對象都向一端移動，而後直接清除掉端邊界之外的內存。

分代算法：根據對象存活週期的不一樣將內存劃分爲幾塊，通常是新生代和老年代，新生代基本採用複製算法，老年代採用標記整理算法。

標記-清除算法

標記無用對象，而後進行清除回收。

標記-清除算法（Mark-Sweep）是一種常見的基礎垃圾收集算法，它將垃圾收集分爲兩個階段：

標記階段：標記出能夠回收的對象。

清除階段：回收被標記的對象所佔用的空間。

標記-清除算法之因此是基礎的，是由於後面講到的垃圾收集算法都是在此算法的基礎上進行改進的。

優勢：實現簡單，不須要對象進行移動。

缺點：標記、清除過程效率低，產生大量不連續的內存碎片，提升了垃圾回收的頻率。

標記-清除算法的執行的過程以下圖所示

複製算法

爲了解決標記-清除算法的效率不高的問題，產生了複製算法。它把內存空間劃爲兩個相等的區域，每次只使用其中一個區域。垃圾收集時，遍歷當前使用的區域，把存活對象複製到另一個區域中，最後將當前使用的區域的可回收的對象進行回收。

優勢：按順序分配內存便可，實現簡單、運行高效，不用考慮內存碎片。

缺點：可用的內存大小縮小爲原來的一半，對象存活率高時會頻繁進行復制。

複製算法的執行過程以下圖所示

標記-整理算法

在新生代中可使用複製算法，可是在老年代就不能選擇複製算法了，由於老年代的對象存活率會較高，這樣會有較多的複製操做，致使效率變低。

標記-清除算法能夠應用在老年代中，可是它效率不高，在內存回收後容易產生大量內存碎片。所以就出現了一種標記-整理算法（Mark-Compact）算法，與標記-整理算法不一樣的是，在標記可回收的對象後將全部存活的對象壓縮到內存的一端，使他們緊湊的排列在一塊兒，而後對端邊界之外的內存進行回收。回收後，已用和未用的內存都各自一邊。

優勢：解決了標記-清理算法存在的內存碎片問題。

缺點：仍須要進行局部對象移動，必定程度上下降了效率。

標記-整理算法的執行過程以下圖所示

分代收集算法

當前商業虛擬機都採用 分代收集的垃圾收集算法。分代收集算法，顧名思義是根據對象的存活週期將內存劃分爲幾塊。通常包括年輕代、老年代和 永久代，如圖所示：（後面有重點講解）

JVM中的永久代中會發生垃圾回收嗎

垃圾回收不會發生在永久代，若是永久代滿了或者是超過了臨界值，會觸發徹底垃圾回收(Full GC)。若是你仔細查看垃圾收集器的輸出信息，就會發現永久代也是被回收的。這就是爲何正確的永久代大小對避免Full GC是很是重要的緣由。請參考下Java8：從永久代到元數據區
(注：Java8中已經移除了永久代，新加了一個叫作元數據區的native內存區)

垃圾收集器以及新生代、老年代、永久代

講一下新生代、老年代、永久代的區別

在 Java 中，堆被劃分紅兩個不一樣的區域：新生代 ( Young )、老年代 ( Old )。而新生代 ( Young ) 又被劃分爲三個區域：Eden、From Survivor、To Survivor。這樣劃分的目的是爲了使 JVM 可以更好的管理堆內存中的對象，包括內存的分配以及回收。

新生代中通常保存新出現的對象，因此每次垃圾收集時都發現大批對象死去，只有少許對象存活，便採用了複製算法，只須要付出少許存活對象的複製成本就能夠完成收集。

老年代中通常保存存活了好久的對象，他們存活率高、沒有額外空間對它進行分配擔保，就必須採用「標記-清理」或者「標記-整理」算法。

永久代就是JVM的方法區。在這裏都是放着一些被虛擬機加載的類信息，靜態變量，常量等數據。這個區中的東西比老年代和新生代更不容易回收。

Minor GC、Major GC、Full GC是什麼

Minor GC是新生代GC，指的是發生在新生代的垃圾收集動做。因爲java對象大都是朝生夕死的，因此Minor GC很是頻繁，通常回收速度也比較快。（通常採用複製算法回收垃圾）

Major GC是老年代GC，指的是發生在老年代的GC，一般執行Major GC會連着Minor GC一塊兒執行。Major GC的速度要比Minor GC慢的多。（可採用標記清楚法和標記整理法）

Full GC是清理整個堆空間，包括年輕代和老年代

Minor GC、Major GC、Full GC區別及觸發條件

Minor GC 觸發條件通常爲：

eden區滿時，觸發MinorGC。即申請一個對象時，發現eden區不夠用，則觸發一次MinorGC。

新建立的對象大小 > Eden所剩空間時觸發Minor GC

Major GC和Full GC 觸發條件通常爲：

Major GC一般是跟full GC是等價的

• 每次晉升到老年代的對象平均大小>老年代剩餘空間
• MinorGC後存活的對象超過了老年代剩餘空間
• 永久代空間不足
• 執行System.gc()
• CMS GC異常
• 堆內存分配很大的對象

爲何新生代要分Eden和兩個 Survivor 區域？

若是沒有Survivor，Eden區每進行一次Minor GC，存活的對象就會被送到老年代。老年代很快被填滿，觸發Major GC.老年代的內存空間遠大於新生代，進行一次Full GC消耗的時間比Minor GC長得多,因此須要分爲Eden和Survivor。

Survivor的存在乎義，就是減小被送到老年代的對象，進而減小Full GC的發生，Survivor的預篩選保證，只有經歷15次Minor GC還能在新生代中存活的對象，纔會被送到老年代。

設置兩個Survivor區最大的好處就是解決了碎片化，剛剛新建的對象在Eden中，經歷一次Minor GC，Eden中的存活對象就會被移動到第一塊survivor space S0，Eden被清空；等Eden區再滿了，就再觸發一次Minor GC，Eden和S0中的存活對象又會被複制送入第二塊survivor space S1（這個過程很是重要，由於這種複製算法保證了S1中來自S0和Eden兩部分的存活對象佔用連續的內存空間，避免了碎片化的發生）

Java堆老年代( Old ) 和新生代 ( Young ) 的默認比例？

默認的，新生代 ( Young ) 與老年代 ( Old ) 的比例的值爲 1:2 ( 該值能夠經過參數 –XX:NewRatio 來指定 )，即：新生代 ( Young ) = 1/3 的堆空間大小。老年代 ( Old ) = 2/3 的堆空間大小。

其中，新生代 ( Young ) 被細分爲 Eden 和 兩個 Survivor 區域，Edem 和倆個Survivor 區域比例是 = 8 : 1 : 1 ( 能夠經過參數 –XX:SurvivorRatio 來設定 )，

可是JVM 每次只會使用 Eden 和其中的一塊 Survivor 區域來爲對象服務，因此不管何時，老是有一塊 Survivor 區域是空閒着的。

爲何要這樣分代：

其實主要緣由就是能夠根據各個年代的特色進行對象分區存儲，更便於回收，採用最適當的收集算法：

新生代中，每次垃圾收集時都發現大批對象死去，只有少許對象存活，便採用了複製算法，只須要付出少許存活對象的複製成本就能夠完成收集。

而老年代中由於對象存活率高、沒有額外空間對它進行分配擔保，就必須採用「標記-清理」或者「標記-整理」算法。

新生代又分爲Eden和Survivor （From與To，這裏簡稱一個區）兩個區。

加上老年代就這三個區。數據會首先分配到Eden區當中（固然也有特殊狀況，若是是大對象那麼會直接放入到老年代（大對象是指須要大量連續內存空間的java對象）。

當Eden沒有足夠空間的時候就會觸發jvm發起一次Minor GC，。若是對象通過一次Minor-GC還存活，而且又能被Survivor空間接受，那麼將被移動到Survivor空間當中。並將其年齡設爲1，對象在Survivor每熬過一次Minor GC，年齡就加1，當年齡達到必定的程度（默認爲15）時，就會被晉升到老年代中了，固然晉升老年代的年齡是能夠設置的。

什麼是垃圾回收器他和垃圾算法有什麼區別

垃圾收集器是垃圾回收算法（標記清楚法、標記整理法、複製算法、分代算法）的具體實現，不一樣垃圾收集器、不一樣版本的JVM所提供的垃圾收集器可能會有很在差異。

說一下 JVM 有哪些垃圾回收器？

若是說垃圾收集算法是內存回收的方法論，那麼垃圾收集器就是內存回收的具體實現。下圖展現了7種做用於不一樣分代的收集器，其中用於回收新生代的收集器包括Serial、PraNew、Parallel Scavenge，回收老年代的收集器包括Serial Old、Parallel Old、CMS，還有用於回收整個Java堆的G1收集器。不一樣收集器之間的連線表示它們能夠搭配使用。

Serial收集器（複製算法): 新生代單線程收集器，標記和清理都是單線程，優勢是簡單高效；

ParNew收集器 (複製算法): 新生代收並行集器，其實是Serial收集器的多線程版本，在多核CPU環境下有着比Serial更好的表現；

Parallel Scavenge收集器 (複製算法): 新生代並行收集器，追求高吞吐量，高效利用 CPU。吞吐量 = 用戶線程時間/(用戶線程時間+GC線程時間)，高吞吐量能夠高效率的利用CPU時間，儘快完成程序的運算任務，適合後臺應用等對交互相應要求不高的場景；

Serial Old收集器 (標記-整理算法): 老年代單線程收集器，Serial收集器的老年代版本；

Parallel Old收集器 (標記-整理算法)： 老年代並行收集器，吞吐量優先，Parallel Scavenge收集器的老年代版本；

CMS(Concurrent Mark Sweep)收集器（標記-清除算法）： 老年代並行收集器，以獲取最短回收停頓時間爲目標的收集器，具備高併發、低停頓的特色，追求最短GC回收停頓時間。

G1(Garbage First)收集器 ( 標記整理 + 複製算法來回收垃圾 )： Java堆並行收集器，G1收集器是JDK1.7提供的一個新收集器，G1收集器基於「標記-整理」算法實現，也就是說不會產生內存碎片。此外，G1收集器不一樣於以前的收集器的一個重要特色是：G1回收的範圍是整個Java堆(包括新生代，老年代)，而前六種收集器回收的範圍僅限於新生代或老年代。

收集器能夠這麼分配？（瞭解就行了）

1. Serial / Serial Old
2. Serial / CMS
3. ParNew / Serial Old
4. ParNew / CMS
5. Parallel Scavenge / Serial Old
6. Parallel Scavenge / Parallel Old
7. G1

新生代垃圾回收器和老年代垃圾回收器都有哪些？有什麼區別？

1. 新生代回收器：Serial、ParNew、Parallel Scavenge
2. 老年代回收器：Serial Old、Parallel Old、CMS
3. 整堆回收器：G1

新生代垃圾回收器通常採用的是複製算法，複製算法的優勢是效率高，缺點是內存利用率低；老年代回收器通常採用的是標記-整理的算法進行垃圾回收。

簡述分代垃圾回收器是怎麼工做的？

1.分代回收器有兩個分區：老生代和新生代，新生代默認的空間佔比總空間的 1/3，老生代的默認佔比是 2/3。

2.新生代使用的是複製算法，新生代裏有 3 個分區：Eden、To Survivor、From Survivor，它們的默認佔比是 8:1:1，它的執行流程以下：

1. 把 Eden + From Survivor 存活的對象放入 To Survivor 區；
2. 清空 Eden 和 From Survivor 分區；
3. From Survivor 和 To Survivor 分區交換，From Survivor 變 To Survivor，To Survivor 變 From Survivor。

3.每次在 From Survivor 到 To Survivor 移動時都存活的對象，年齡就 +1，當年齡到達 15（默認配置是 15）時，升級爲老生代。大對象也會直接進入老生代。

4.老生代當空間佔用到達某個值以後就會觸發全局垃圾收回，通常使用標記整理的執行算法。以上這些循環往復就構成了整個分代垃圾回收的總體執行流程。

內存分配策略

簡述java內存分配與回收策率以及Minor GC和Major GC

所謂自動內存管理，最終要解決的也就是內存分配和內存回收兩個問題。前面咱們介紹了內存回收，這裏咱們再來聊聊內存分配。

對象的內存分配一般是在 Java 堆上分配（隨着虛擬機優化技術的誕生，某些場景下也會在棧上分配，後面會詳細介紹），對象主要分配在新生代的 Eden 區，若是啓動了本地線程緩衝，將按照線程優先在 TLAB 上分配。少數狀況下也會直接在老年代上分配。總的來講分配規則不是百分百固定的，其細節取決於哪種垃圾收集器組合以及虛擬機相關參數有關，可是虛擬機對於內存的分配仍是會遵循如下幾種「普世」規則：

對象優先在 Eden 區分配

多數狀況，對象都在新生代 Eden 區分配。當 Eden 區分配沒有足夠的空間進行分配時，虛擬機將會發起一次 Minor GC。若是本次 GC 後仍是沒有足夠的空間，則將啓用分配擔保機制在老年代中分配內存。

這裏咱們提到 Minor GC，若是你仔細觀察過 GC 平常，一般咱們還能從日誌中發現 Major GC/Full GC。
Minor GC 是指發生在新生代的 GC，由於 Java 對象大多都是朝生夕死，全部 Minor GC 很是頻繁，通常回收速度也很是快；
Major GC/Full GC 是指發生在老年代的 GC，出現了 Major GC 一般會伴隨至少一次 Minor GC。Major GC 的速度一般會比 Minor GC 慢 10 倍以上。

爲何大對象直接進入老年代

所謂大對象是指須要大量連續內存空間的對象，頻繁出現大對象是致命的，會致使在內存還有很多空間的狀況下提早觸發 GC 以獲取足夠的連續空間來安置新對象。

前面咱們介紹過新生代使用的是標記-清除算法來處理垃圾回收的，若是大對象直接在新生代分配就會致使 Eden 區和兩個 Survivor 區之間發生大量的內存複製。所以對於大對象都會直接在老年代進行分配。

長期存活對象將進入老年代

虛擬機採用分代收集的思想來管理內存，那麼內存回收時就必須判斷哪些對象應該放在新生代，哪些對象應該放在老年代。所以虛擬機給每一個對象定義了一個對象年齡的計數器，若是對象在 Eden 區出生，而且可以被 Survivor 容納，將被移動到 Survivor 空間中，這時設置對象年齡爲 1。對象在 Survivor 區中每「熬過」一次 Minor GC 年齡就加 1，當年齡達到必定程度（默認 15） 就會被晉升到老年代。

虛擬機類加載機制

簡述java類加載機制?

虛擬機把描述類的數據從Class文件加載到內存，並對數據進行校驗，解析和初始化，最終造成能夠被虛擬機直接使用的java類型。

類加載的機制及過程

程序主動使用某個類時，若是該類還未被加載到內存中，則JVM會經過加載、鏈接、初始化3個步驟來對該類進行初始化。若是沒有意外，JVM將會連續完成3個步驟，因此有時也把這個3個步驟統稱爲類加載或類初始化。

一、加載

加載指的是將類的class文件讀入到內存，並將這些靜態數據轉換成方法區中的運行時數據結構，並在堆中生成一個表明這個類的java.lang.Class對象，做爲方法區類數據的訪問入口，這個過程須要類加載器參與。

Java類加載器由JVM提供，是全部程序運行的基礎，JVM提供的這些類加載器一般被稱爲系統類加載器。除此以外，開發者能夠經過繼承ClassLoader基類來建立本身的類加載器。

類加載器，能夠從不一樣來源加載類的二進制數據，好比：本地Class文件、Jar包Class文件、網絡Class文件等等等。

類加載的最終產物就是位於堆中的Class對象（注意不是目標類對象），該對象封裝了類在方法區中的數據結構，而且向用戶提供了訪問方法區數據結構的接口，即Java反射的接口

二、鏈接過程

當類被加載以後，系統爲之生成一個對應的Class對象，接着將會進入鏈接階段，鏈接階段負責把類的二進制數據合併到JRE中（意思就是將java類的二進制代碼合併到JVM的運行狀態之中）。類鏈接又可分爲以下3個階段。

驗證：確保加載的類信息符合JVM規範，沒有安全方面的問題。主要驗證是否符合Class文件格式規範，而且是否能被當前的虛擬機加載處理。

準備：正式爲類變量（static變量）分配內存並設置類變量初始值的階段，這些內存都將在方法區中進行分配

解析：虛擬機常量池的符號引用替換爲字節引用過程

三、初始化

初始化階段是執行類構造器<clinit>() 方法的過程。類構造器<clinit>()方法是由編譯器自動收藏類中的全部類變量的賦值動做和靜態語句塊(static塊)中的語句合併產生，代碼從上往下執行。

當初始化一個類的時候，若是發現其父類尚未進行過初始化，則須要先觸發其父類的初始化

虛擬機會保證一個類的<clinit>() 方法在多線程環境中被正確加鎖和同步

初始化的總結就是：初始化是爲類的靜態變量賦予正確的初始值

描述一下JVM加載Class文件的原理機制

Java中的全部類，都須要由類加載器裝載到JVM中才能運行。類加載器自己也是一個類，而它的工做就是把class文件從硬盤讀取到內存中。在寫程序的時候，咱們幾乎不須要關心類的加載，由於這些都是隱式裝載的，除非咱們有特殊的用法，像是反射，就須要顯式的加載所須要的類。

類裝載方式，有兩種 ：

1.隱式裝載， 程序在運行過程當中當碰到經過new 等方式生成對象時，隱式調用類裝載器加載對應的類到jvm中，

2.顯式裝載， 經過class.forname()等方法，顯式加載須要的類

Java類的加載是動態的，它並不會一次性將全部類所有加載後再運行，而是保證程序運行的基礎類(像是基類)徹底加載到jvm中，至於其餘類，則在須要的時候才加載。這固然就是爲了節省內存開銷。

什麼是類加載器，類加載器有哪些?

實現經過類的權限定名獲取該類的二進制字節流的代碼塊叫作類加載器。

主要有一下四種類加載器:

啓動類加載器(Bootstrap ClassLoader)用來加載java核心類庫，沒法被java程序直接引用。

擴展類加載器(extensions class loader):它用來加載 Java 的擴展庫。Java 虛擬機的實現會提供一個擴展庫目錄。該類加載器在此目錄裏面查找並加載 Java 類。

系統類加載器（system class loader）：它根據 Java 應用的類路徑（CLASSPATH）來加載 Java 類。通常來講，Java 應用的類都是由它來完成加載的。能夠經過 ClassLoader.getSystemClassLoader()來獲取它。

用戶自定義類加載器，經過繼承 java.lang.ClassLoader類的方式實現。

說一下類裝載的執行過程？

類裝載分爲如下 5 個步驟：

1. 加載：根據查找路徑找到相應的 class 文件而後導入；
2. 驗證：檢查加載的 class 文件的正確性；
3. 準備：給類中的靜態變量分配內存空間；
4. 解析：虛擬機將常量池中的符號引用替換成直接引用的過程。符號引用就理解爲一個標示，而在直接引用直接指向內存中的地址；
5. 初始化：對靜態變量和靜態代碼塊執行初始化工做。

什麼是雙親委派模型？

在介紹雙親委派模型以前先說下類加載器。對於任意一個類，都須要由加載它的類加載器和這個類自己一同確立在 JVM 中的惟一性，每個類加載器，都有一個獨立的類名稱空間。類加載器就是根據指定全限定名稱將 class 文件加載到 JVM 內存，而後再轉化爲 class 對象。

類加載器分類：

• 啓動類加載器（Bootstrap ClassLoader），是虛擬機自身的一部分，用來加載Java_HOME/lib/目錄中的，或者被 -Xbootclasspath 參數所指定的路徑中而且被虛擬機識別的類庫；
• 其餘類加載器：
• 擴展類加載器（Extension ClassLoader）：負責加載libext目錄或Java. ext. dirs系統變量指定的路徑中的全部類庫；
• 應用程序類加載器（Application ClassLoader）。負責加載用戶類路徑（classpath）上的指定類庫，咱們能夠直接使用這個類加載器。通常狀況，若是咱們沒有自定義類加載器默認就是用這個加載器。

雙親委派模型：若是一個類加載器收到了類加載的請求，它首先不會本身去加載這個類，而是把這個請求委派給父類加載器去完成，每一層的類加載器都是如此，這樣全部的加載請求都會被傳送到頂層的啓動類加載器中，只有當父加載沒法完成加載請求（它的搜索範圍中沒找到所需的類）時，子加載器纔會嘗試去加載類。

總結就是：當一個類收到了類加載請求時，不會本身先去加載這個類，而是將其委派給父類，由父類去加載，若是此時父類不能加載，反饋給子類，由子類去完成類的加載。

JVM調優

JVM 調優的參數能夠在那設置參數值

• 能夠在IDEA，Eclipse，工具裏設置
• 若是上線了是WAR包的話能夠在Tomcat設置
• 若是是Jar包直接 ：java -jar 是直接插入JVM命令就行了

java -Xms1024m -Xmx1024m ...等等等 JVM參數 -jar springboot_app.jar &

說一下 JVM 調優的工具？

JDK 自帶了不少監控工具，都位於 JDK 的 bin 目錄下，其中最經常使用的是 jconsole 和 jvisualvm 這兩款視圖監控工具。

jconsole：用於對 JVM 中的內存、線程和類等進行監控；

jvisualvm：JDK 自帶的全能分析工具，能夠分析：內存快照、線程快照、程序死鎖、監控內存的變化、gc 變化等。

經常使用的 JVM 調優的參數都有哪些？

##### #經常使用的設置
-Xms：初始堆大小，JVM 啓動的時候，給定堆空間大小。 

-Xmx：最大堆大小，JVM 運行過程當中，若是初始堆空間不足的時候，最大能夠擴展到多少。 

-Xmn：設置堆中年輕代大小。整個堆大小=年輕代大小+年老代大小+持久代大小。 

-XX:NewSize=n 設置年輕代初始化大小大小 

-XX:MaxNewSize=n 設置年輕代最大值

-XX:NewRatio=n 設置年輕代和年老代的比值。如: -XX:NewRatio=3，表示年輕代與年老代比值爲 1：3，年輕代佔整個年輕代+年老代和的 1/4 

-XX:SurvivorRatio=n 年輕代中 Eden 區與兩個 Survivor 區的比值。注意 Survivor 區有兩個。8表示兩個Survivor :eden=2:8 ,即一個Survivor佔年輕代的1/10，默認就爲8

-Xss：設置每一個線程的堆棧大小。JDK5後每一個線程 Java 棧大小爲 1M，之前每一個線程堆棧大小爲 256K。

-XX:ThreadStackSize=n 線程堆棧大小

-XX:PermSize=n 設置持久代初始值    

-XX:MaxPermSize=n 設置持久代大小
 
-XX:MaxTenuringThreshold=n 設置年輕帶垃圾對象最大年齡。若是設置爲 0 的話，則年輕代對象不通過 Survivor 區，直接進入年老代。

#### #下面是一些不經常使用的

-XX:LargePageSizeInBytes=n 設置堆內存的內存頁大小

-XX:+UseFastAccessorMethods 優化原始類型的getter方法性能

-XX:+DisableExplicitGC 禁止在運行期顯式地調用System.gc()，默認啓用    

-XX:+AggressiveOpts 是否啓用JVM開發團隊最新的調優成果。例如編譯優化，偏向鎖，並行年老代收集等，jdk6紙以後默認啓動

-XX:+UseBiasedLocking 是否啓用偏向鎖，JDK6默認啓用    

-Xnoclassgc 是否禁用垃圾回收

-XX:+UseThreadPriorities 使用本地線程的優先級，默認啓用

JVM的GC收集器設置

-xx:+Use  xxx   GC   `xxx   表明垃圾收集器名稱`

-XX:+UseSerialGC:設置串行收集器，年輕帶收集器 

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

-XX:+UseParallelGC:設置並行收集器，目標是目標是達到可控制的吞吐量

-XX:+UseParallelOldGC:設置並行年老代收集器，JDK6.0 支持對年老代並行收集。 

-XX:+UseConcMarkSweepGC:設置年老代併發收集器

-XX:+UseG1GC:設置 G1 收集器，JDK1.9默認垃圾收集器