1. Java 虛擬機內存區概述

我們在編寫程序時，經常會遇到OOM(out of Memory)以及內存泄漏等問題。為了避免出現這些問題，我們首先必須對JVM的內存劃分有個具體的認識。JVM將內存主要劃分為：方法區、虛擬機棧、本地方法棧、堆、程序計數器。

2. Java 虛擬機運行時數據區

2.1. 運行時數據區劃分

2.1.1 運行時數據區圖

 

2.1.2 運行時數據區包括

• 方法區(Method Area)
• 虛擬機棧(VM Stack)
• 本地方法棧(Native Method Stack)
• 堆(Heap)
• 程序計算器(Program Counter Register)

2.2. 方法區(Method Area)

2.2.1 方法區的概念

方法區又叫靜態區，存放的是已加載的類的基本信息、常量、靜態變量等。它是各個線程共享區域。

比方說我們在寫Java代碼時，每個線程度可以訪問同一個類的靜態變量對象。由于使用反射機制的原因，虛擬機很難推測哪那個類信息不再使用，因此這塊區域的回收很難。

2.2.1.1 靜態塊和非靜態塊有什么區別?

• 類(Class)和對象(Object)的區別與聯系?
• 為什么靜態塊中不能使用this、super關鍵字?
• 為什么java的靜態方法可以直接用類名調用?

2.2.2 方法區的特點

線程間共享區域

2.2.3 方法區的異常

對這塊區域主要是針對常量池回收，值得注意的是JDK1.7已經把常量池轉移到堆里面了。同樣，當方法區無法滿足內存分配需求時，會拋出OutOfMemoryError。制造方法區內存溢出，注意，必須在JDK1.6及之前版本才會導致方法區溢出，原因后面解釋,執行之前，可以把虛擬機的參數-XXpermSize和-XX：MaxPermSize限制方法區大小。

代碼清單如下：

public static void printOOM() { 
 List<String> list = new ArrayList<String>(); 
 int i = 0; 
 while (true) { 
 list.add(String.valueOf(i).intern()); 
 } 
} 

輸出異常結果：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space 
 at java.util.Arrays.copyOf(Arrays.java:2245) 
 at java.util.Arrays.copyOf(Arrays.java:2219) 
 at java.util.ArrayList.grow(ArrayList.java:242) 
 at java.util.ArrayList.ensureExplicitCapacity(ArrayList.java:216) 
 at java.util.ArrayList.ensureCapacityInternal(ArrayList.java:208) 
 at java.util.ArrayList.add(ArrayList.java:440) 
 at com.vprisk.knowledgeshare.MethodAreExample.main(MethodAreExample.java:15) 
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) 
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) 
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) 
 at java.lang.reflect.Method.invoke(Method.java:606) 
 at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147) 

備注：網上的例子運行后會拋出java.lang.OutOfMemoryError:PermGen space異常。

2.2.3.1 關于String的intern()函數

intern()的作用:

如果當前的字符串在常量池中不存在，則放入到常量池中。

上面的代碼不斷將字符串添加到常量池，最終肯定會導致內存不足，拋出方法區的OOM。解釋一下，為什么必須將上面的代碼在JDK1.6之前運行。我們前面提到JDK1.7后，把常量池放入到堆空間中，這導致intern()函數的功能不同，代碼清單如下：

public static void testInternMethod(){ 
 String str1 =new StringBuilder("hua").append("chao").toString(); 
 System.out.println(str1.intern()==str1); 
 String str2=new StringBuilder("ja").append("va").toString(); 
 System.out.println(str2.intern()==str2); 
} 

在場景jdk6，輸出結果：

false , false 

在場景jdk7，輸出結果：

true , false 

為什么了?

原因是在JDK1.6中，intern()方法會把***遇到的字符串實例復制到常量池中，返回的也是常量池中的字符串的引用，而StringBuilder創建的字符串實例是在堆上面，所以必然不是同一個引用，返回false。在JDK1.7中，intern方法不再復制實例，常量池中只保存***出現的實例的引用，因此intern()返回的引用和由StringBuilder創建的字符串實例是同一個。為什么對str2比較返回的是false呢?這是因為，JVM中內部在加載類的時候，就已經有”java”這個字符串，不符合“***出現”的原則，因此返回false。

2.2.4 方法區的作用

方法區存放的是類信息、常量、靜態變量等，是各個線程共享區域

2.2.5 方法區的運用

通過過設置虛擬機的參數 -XXpermSize 以及 -XX：MaxPermSize 限制方法區大小

2.2.6 方法區的使用場景

2.3. 虛擬機棧(VM Stack)

2.3.1 虛擬機棧的概念

虛擬機棧描述的是Java方法執行的內存模型：

每個方法被執行的時候都會同時創建一個棧幀 (StackFrame)用于存儲局部變量表、操作棧、動態鏈接、方法出口等信息。每一個方法被調用直至執行完成的過程，就對應著一個棧幀在虛擬機棧中從入棧到出棧的過程

2.3.1.1 局部變量表

局部變量表存放了編譯器克制的各種基本數據類型(boolean、byte、char、short、int、float、long、double)、對象引用(Object reference)和字節碼指令地址(returnAddress類型)。

2.3.1.1 操作棧

操作數棧也常被稱為操作棧，它是一個后入先出(Last In First Out, LIFO)棧。同局部變量表一樣，操作數棧的***深度也在編譯的時候被寫入到Code屬性的max_stacks數據項之中。操作數棧的每一個元素可以是任意的Java數據類型，包括long和double。32位數據類型所占的棧容量為1，64位數據類型所占的棧容量為2。在方法執行的任何時候，操作數棧的深度都不會超過在max_stacks數據項中設定的***值。

當一個方法剛剛開始執行的時候，這個方法的操作數棧是空的，在方法的執行過程中，會有各種字節碼指令向操作數棧中寫入和提取內容，也就是入棧出棧操作。例如，在做算術運算的時候是通過操作數棧來進行的，又或者在調用其他方法的時候是通過操作數棧來進行參數傳遞的。

舉個例子，整數加法的字節碼指令iadd在運行的時候要求操作數棧中最接近棧頂的兩個元素已經存入了兩個int型的數值，當執行這個指令時，會將這兩個int值和并相加，然后將相加的結果入棧。

操作數棧中元素的數據類型必須與字節碼指令的序列嚴格匹配，在編譯程序代碼的時候，編譯器要嚴格保證這一點，在類校驗階段的數據流分析中還要再次驗證這一點。再以上面的iadd指令為例，這個指令用于整型數加法，它在執行時，最接近棧頂的兩個元素的數據類型必須為int型，不能出現一個long和一個float使用iadd命令相加的情況。

2.3.1.1 動態鏈接

每個棧幀都包含一個指向運行時常量池中該棧幀所屬方法的引用，持有這個引用是為了支持方法調用過程中的動態連接。我們知道Class文件的常量池有存有大量的符號引用，字節碼中的方法調用指令就以常量池中指向方法的符號引用為參數。這些符號引用一部分會在類加載階段或***次使用的時候轉化為直接引用，這種轉化稱為靜態解析。另外一部分將在每一次的運行期間轉化為直接引用，這部分稱為動態連接。

2.3.2 虛擬機棧的特點

• 線程私有
• 生命周期與線程相同

2.3.3 虛擬機棧的異常

2.3.3.1 一種是StackOverflowError

當前線程如果請求的棧深度大于虛擬機所允許的深度時，則會拋出該異常。例如，將一個函數反復遞歸自己，最終會出現棧溢出錯誤(StackOverflowError)。

代碼清單如下：

public class StackOverflowErrorDemo { 
 public static void main(String []args){ 
 printStackOverflowError(); 
 } 
 public static void printStackOverflowError(){ 
 printStackOverflowError(); 
 } 
} 

輸出異常結果：

Exception in thread "main" java.lang.StackOverflowError 
stack length：9482 
 at com.itech.jvm.demo.StackOverflowErrorDemo.printStackOverflowError(StackOverflowErrorDemo.java:22) 
 at com.itech.jvm.demo.StackOverflowErrorDemo.printStackOverflowError(StackOverflowErrorDemo.java:22) 
 at com.itech.jvm.demo.StackOverflowErrorDemo.printStackOverflowError(StackOverflowErrorDemo.java:22) 
 at com.itech.jvm.demo.StackOverflowErrorDemo.printStackOverflowError(StackOverflowErrorDemo.java:22) 
 at com.itech.jvm.demo.StackOverflowErrorDemo.printStackOverflowError(StackOverflowErrorDemo.java:22) 
 at com.itech.jvm.demo.StackOverflowErrorDemo.printStackOverflowError(StackOverflowErrorDemo.java:22) 
 at com.itech.jvm.demo.StackOverflowErrorDemo.printStackOverflowError(StackOverflowErrorDemo.java:22) 
 at com.itech.jvm.demo.StackOverflowErrorDemo.printStackOverflowError(StackOverflowErrorDemo.java:22) 
 at com.itech.jvm.demo.StackOverflowErrorDemo.printStackOverflowError(StackOverflowErrorDemo.java:22) 

需要說明的是，在單個線程環境下，無論是棧幀太大，還是虛擬機棧容量太小，當內存無法分配時，虛擬機都會拋出 StackOverflowError 異常。

2.3.3.2 一種是OOM異常

當虛擬機棧支持動態擴展時，如果無法申請到足夠多的內存時就會拋出OOM異常。代碼清單如下：

public class VMOOMDemo { 
 public static void main(String[] args) throws Throwable { 
 VMOOMDemo demo = new VMOOMDemo(); 
 demo.printVMOOM(); 
 } 
 public void printVMOOM() { 
 while (true) { 
 new Thread() { 
 public void run() { 
 while (true) { 
 } 
 } 
 }.start(); 
 } 
 } 
} 

這個例子慎用...

本例通過不斷地建立線程的方式產生內存溢出異常。但是，這樣產生的內存溢出異常與棧空間是否足夠大并不存在任何聯系，或者準確地說，在這種情況下，給每個線程的棧分配的內存越大，反而越容易產生內存溢出異常。 其原因是操作系統分配給每個進程的內存是有限制的，如32位的Windows限制為2GB。。

2.3.4 虛擬機棧的作用

用于存儲局部變量、操作棧、動態鏈接、方法出口

2.3.5 虛擬機棧的運用

對于32位的jvm，默認大小為256kb, 而64位的jvm, 默認大小為512kb,可以通過-Xss設置虛擬機棧的***值。不過如果設置過大，會影響到可創建的線程數量。

2.3.6 虛擬機棧的使用場景

2.4. 本地方法棧(Native Method Stack)

2.4.1 本地方法棧的概念

本地方法棧與虛擬機棧所發揮的作用很相似，他們的區別在于虛擬機棧為執行Java代碼方法服務，而本地方法棧是為Native方法服務。與虛擬機棧一樣，本地方法棧也會拋出StackOverflowError和OutOfMemoryError異常。

2.4.2 本地方法棧的特點

• 線程私有
• 為Native方法服務

2.4.3 本地方法棧的異常

與虛擬機棧一樣，本地方法棧也會拋出StackOverflowError和OutOfMemoryError異常。

2.4.4 本地方法棧的作用

2.4.4.1 與java環境外交互

有時java應用需要與java外面的環境交互。這是本地方法存在的主要原因，你可以想想java需要與一些底層系統如操作系統或某些硬件交換信息時的情況。本地方法正是這樣一種交流機制：它為我們提供了一個非常簡潔的接口，而且我們無需去了解java應用之外的繁瑣的細節。

2.4.4.2 與操作系統交互

JVM支持著java語言本身和運行時庫，它是java程序賴以生存的平臺，它由一個解釋器(解釋字節碼)和一些連接到本地代碼的庫組成。然而不管怎樣，它畢竟不是一個完整的系統，它經常依賴于一些底層(underneath在下面的)系統的支持。這些底層系統常常是強大的操作系統。通過使用本地方法，我們得以用java實現了jre的與底層系統的交互，甚至JVM的一些部分就是用C寫的，還有，如果我們要使用一些java語言本身沒有提供封裝的操作系統的特性時，我們也需要使用本地方法。

Sun's Java Sun的解釋器是用C實現的，這使得它能像一些普通的C一樣與外部交互。jre大部分是用java實現的，它也通過一些本地方法與外界交互。例如：類java.lang.Thread

的 setPriority()方法是用java實現的，但是它實現調用的是該類里的本地方法setPriority0()。這個本地方法是用C實現的，并被植入JVM內部，在Windows 95的平臺上，這個本地方法最終將調用Win32 SetPriority() API。這是一個本地方法的具體實現由JVM直接提供，更多的情況是本地方法由外部的動態鏈接庫(external dynamic link library)提供，然后被JVM調用。

2.4.5 本地方法棧的運用

2.4.6 本地方法棧的使用場景

• 與java環境外交互
• 與操作系統交互

2.5. Java堆(Heap)

2.5.1 Java 堆的概念

Java堆可以說是虛擬機中***一塊內存了。它是所有線程所共享的內存區域，幾乎所有的實例對象都是在這塊區域中存放。當然，隨著JIT編譯器的發展，所有對象在堆上分配漸漸變得不那么“絕對”了。

Java堆是垃圾收集器管理的主要區域。由于現在的收集器基本上采用的都是分代收集算法，所有Java堆可以細分為：新生代和老年代。在細致分就是把新生代分為：

• Eden空間
• From Survivor
• To Survivor

根據Java 虛擬機規范的規定：

Java堆可以處于物理上不連續的內存空間中，只要邏輯上是連續的即可，就像我們的磁盤空間一樣。在實現時，既可以實現成固定大小的，也可以是可擴展的，不過當前主流的虛擬機都是按照可擴展來實現的。

2.5.2 Java 堆的特點

線程間共享區域，在虛擬機啟動時創建

是虛擬機中***的一塊內存，幾乎所有的實例對象都是在這塊區域中存放

2.5.3 Java 堆的異常

當堆無法再擴展時，會拋出OutOfMemoryError異常。

2.5.4 Java 堆的作用

唯一目的就是存放對象實例，幾乎所有的對象實例都在java堆中分配內存

2.5.5 Java 堆的運用

通過 -Xmx 和 -Xms 控制

2.5.6 Java 堆的使用場景

2.6. 程序計算器(Program Counter Register)

2.6.1 程序計算器的概念

類似于PC寄存器，程序計數器是線程私有的區域，每個線程都有自己的程序計算器。可以把它看成是當前線程所執行的字節碼的行號指示器。

2.6.2 程序計算器的特點

• 線程私有
• 占用的內存空間小
• 此內存區域是唯一一個在Java虛擬機規范中沒有規定任何OOM(OutOfMemoryError)情況的區域

2.6.3 程序計算器的異常

此內存區域是唯一一個在Java虛擬機規范中沒有規定任何OOM(OutOfMemoryError)情況的區域

2.6.4 程序計算器的作用

• 信號指示器：多線程間切換時，需恢復每一個線程的當前執行位置，通過程序計數器中的值尋找要執行的指令的字節碼
• 如果線程在執行Java方法，計數器記錄的是正在執行的虛擬機字節碼指令地址;如果執行的是Native方法，計數器的值為空(Undefined)。

2.6.5 程序計算器的運用

通過 -Xmx 和 -Xms 控制

2.6.6 程序計算器的使用場景

2.7. 直接內存

2.7.1 直接內存的概念

2.7.1.1 什么是直接內存與非直接內存?

根據官方文檔的描述：

A byte buffer is either direct or non-direct. Given a direct byte buffer, the Java virtual machine will make a best effort to perform native I/O operations directly upon it. That is, it will attempt to avoid copying the buffer's content to (or from) an intermediate buffer before (or after) each invocation of one of the underlying operating system's native I/O operations.

byte byffer可以是兩種類型，一種是基于直接內存(也就是非堆內存);另一種是非直接內存(也就是堆內存)。

直接內存(Direct Memory)既不屬于虛擬機運行時數據區的一部分，也不屬于Java虛擬機規范中定義的內存區域，但是這部分內存卻被頻繁地使用，而且還可能導致OutOfMemoryError異常出現。

對于直接內存來說，JVM將會在IO操作上具有更高的性能，因為它直接作用于本地系統的IO操作。而堆內存如果要作IO操作，會先復制到直接內存，再利用本地IO處理。

從數據流的角度，非直接內存的作用鏈：

本地IO-->直接內存-->非直接內存-->直接內存-->本地IO

而直接內存的作用鏈：

本地IO-->直接內存-->本地IO

很明顯，在做IO處理時，比如網絡發送大量數據時，直接內存會具有更高的效率。

A direct byte buffer may be created by invoking the allocateDirect factory method of this class. The buffers returned by this method typically have somewhat higher allocation and deallocation costs than non-direct buffers. The contents of direct buffers may reside outside of the normal garbage-collected heap, and so their impact upon the memory footprint(內存占用) of an application might not be obvious. It is therefore recommended that direct buffers be allocated primarily for large, long-lived buffers that are subject to the underlying system's native I/O operations. In general it is best to allocate direct buffers only when they yield a measureable gain in program performance.

但是由于直接內存使用allocateDirect創建，它比申請普通的堆內存需要耗費更高的性能。不過它不會占用應用的堆內存。所以，當你有大量數據要緩存時，并且它的生命周期又比較長，那么使用直接內存是個不錯的選擇。但如果該選擇不能帶來顯著的性能提升，推薦使用堆內存。在JDK1.4的NIO中，ByteBuffer有個方法是：

public static ByteBuffer allocateDirect(int capacity) { 
 return new DirectByteBuffer(capacity); 
} 
DirectByteBuffer(int cap) { 
 ...... 
 protected static final Unsafe unsafe = Bits.unsafe(); 
 unsafe.allocateMemory(size); 
 ...... 
} 
public final class Unsafe { 
 ...... 
 public native long allocateMemory(long var1); 
 ...... 
} 

另外直接內受限于本機總內存(包括RAM及SWAP區或者分頁文件)的大小及處理器尋址空間的限制。

服務器管理員配置虛擬機參數時，一般會根據實際內存設置-Xmx等參數信息，但經常會忽略掉直接內存，使得各個內存區域的總和大于物理內存限制(包括物理上的和操作系統級的限制)，從而導致動態擴展時出現OutOfMemoryError異常。

2.7.2 直接內存的特點

• 不受Java堆大小的限制
• 既不是虛擬機運行時數據區的一部分，也不是Java虛擬機規范中定義的內存區域，不會占用應用的內存
• IO操作上具有更高的性能，因為它直接作用于本地系統的IO操作
• 它比申請普通的堆內存需要耗費更高的性能。

2.7.3 直接內存的異常

動態擴展時出現OutOfMemoryError異常

2.7.4 直接內存的作用

基于通道(Channel)與緩沖區(Buffer)的I/O方式，它可以使用Native函數庫直接分配堆外內存，然后通過一個存儲在Java堆里面的DirectByteBuffer對象作為這塊內存的引用進行操作。這樣能在一些場景中顯著提高性能，因為避免了在Java堆和Native堆中來回復制數據。

2.7.5 直接內存的運用

XX:MaxDirectMemorySize=10M

2.7.6 直接內存的使用場景

例如在IO處理時，比如網絡發送大量數據時，直接內存會具有更高的效率。

本文基于jdk1.6、1.7