資訊專欄INFORMATION COLUMN
摘要：虛擬機棧線程私有，生命周期跟線程相同。堆用于存放對象實例，是虛擬機所管理的內存中最大的一塊，同時也是所有線程共享的一塊內存區域。統計監測工具語法格式如下是虛擬機，在系統上一般就是進程。
JDK、JRE、JVM三者的關系
JDK(Java Development Kit)是針對Java開發的產品、是整個Java的核心，包括Java運行環境JRE、Java工具包和Java基礎類庫。
JRE(Java Runtime Environment)是運行Java程序所必須的環境的集合，包含JVM標準實現及Java核心類庫。
JVM(Java Virtual Machine)是整個Java跨平臺的最核心的部分，能夠運行以Java語言寫作的軟件程序。所有的Java程序都會首先被編譯為.class文件，這種類文件可以在虛擬機上運行，class文件并不直接與機器的操作系統相對應，而是經過虛擬機間接與操作系統交互，由虛擬機將程序解釋給本地系統執行。
Java運行時區域 程序計數器內存中較小的內存空間，通過計數器的值可以選取下一條執行的字節碼指令，分支、循環、跳轉、異常處理、線程恢復等基礎功能都需要依賴這個計數器來完成。
線程私有，生命周期跟線程相同。
如果正在執行一個Native方法，那么這個計數器值將為空。
虛擬機棧線程私有，生命周期跟線程相同。
每個方法在執行同時都會創建一個棧幀，用于存儲局部變量表、操作數棧、動態鏈接、方法出口等信息。
在Java虛擬機規范中，對這個區域規定了兩種異常情況：如果線程請求的棧深度大于虛擬機所允許的深度，將拋出StackOverflowError異常；
如果虛擬機棧可以動態擴展，如果擴展時無法申請到足夠的內存，就會拋出OutOfMemoryError異常。
跟虛擬機棧所發揮的作用相似，區別在于虛擬機棧為虛擬機執行Java(也就是字節碼)服務，而本地方法棧則為虛擬機使用到的Native方法服務。
Java堆用于存放對象實例，是Java虛擬機所管理的內存中最大的一塊，同時也是所有線程共享的一塊內存區域。
因為Java堆是垃圾收集器管理的主要區域，因此很多時候也被稱為“GC"堆。由于現在收集器基本都采用分代收集算法，所以Java堆還可以細分為
新生代
老年代
永久代（永久代是Hotspot虛擬機特有的概念，是方法區的一種實現，別的JVM都沒有這個東西。在Java 8中，永久代被徹底移除，取而代之的是另一塊與堆不相連的本地內存——元空間。）
當一個對象被創建時，它首先進入新生代，之后有可能被轉移到老年代中。
新生代存放著大量的生命很短的對象，因此新生代在三個區域中垃圾回收的頻率最高。為了更高效地進行垃圾回收，把新生代繼續劃分成以下三個空間：
Eden
From Survivor
To Survivor
方法區與Java堆一樣，各個線程共享的內存區域，存儲已被虛擬機加載的類信息、常量、靜態變量、即使編譯器編譯后的代碼等數據。
運行時常量池方法區的一部分，用于存放編譯器生成的各種字面量和符號引用。
運行時常量池相對于class文件常量池的另外一個重要特征是具備動態性，Java語言并不要求常量一定只有編譯期才能產生，也就是并非預置入class文件中常量池的內容才能進入方法區運行時常量池，運行期間也可能將新的常量放入池中，這種特性被開發人員利用得比較多的便是String類的intern()方法。
直接內存在JDK1.4中新加入了NIO類，引入了一種基于通道與緩沖區的I/O方法，它可以使用Native函數庫直接分配堆外內存，然后通過一個存儲在Java堆中的DirectByteBuffer對象作為這塊內存的引用進行操作。
堆外內存之 DirectByteBuffer 詳解
在語言層上，創建對象通常僅僅是一個new關鍵字而已，而當虛擬機遇到一條new執行時，將由一下步驟：
檢查類是否加載、解析、初始化過，沒有則先執行相應的類加載過程。
在堆中分配內存
劃分可用空間：
指針碰撞：堆內存規整
空閑列表：堆內存不規整
并發問題
同步：采用CAS配上失敗重試的方式保證更新操作的原子性
把內存分配動作按照線程劃分在不同的空間之中進行
將分配到的內存空間都初始化零值
設置對象的類實例、元數據、哈希碼、GC分代年齡等信息。
執行
對象在內存中儲存的布局可以分為3塊區域：
對象頭
對象運行時數據、哈希碼、GC分代年齡、鎖狀態標記、線程持有的鎖、偏向線程ID等
類型執行：即對象執向它的類元數據的指針，指明對象數據哪個類的實例。
實例數據
對象真正存儲的有效信息
對齊填充
占位符作用
對象的訪問定位句柄定位
直接指針
內存溢出內存溢出out of memory，是指程序在申請空間時，沒有足夠的內存空間供其使用，出現了Out of memory error。
堆內存溢出當new一個對象或者數組時，如果超出了Jvm的head內存最大限制就會爆出異常。
偽代碼：
while(ture){
new Object();
}
棧內存溢出
在Java虛擬機規范中，對這個棧規定了兩種異常情況，如果線程請求的棧深度大于虛擬機所允許的深度，將拋出StackOutFlowError異常，如果虛擬機可以動態擴展（當前大部分Java虛擬機都可動態擴展，只不過Java虛擬機規范中也允許固定長度的虛擬機棧），當擴展時無法申請得到足夠的內存時將會拋出OutOfMemory。
StackOutFlowError線程中的stack是線程私有的，默認大小通常為1M，可以通過-Xss來設置，-Xss越大，則線程獲取的內存越大。
常見問題在線程內過度的調用函數，函數調用會消耗棧空間。
偽代碼：
public void SOFETest(){
SOFETest();
}
OutOfMemoryError
Java的棧空間被所有線程分配成一塊一塊的，每個線程只占一塊。而Jvm的棧空間的最小分配單位有-Xss來決定。-Xss有兩個語義，即定義每個線程的棧大小，也定義了虛擬機的最小棧內存的分配單位。
如果申請的線程沒有獲得棧空間可以分配了就會拋出OutOfMemoryError。表示棧空間不足，溢出異常。
代碼：該代碼可能導致JVM無法申請得到太多的棧內存而導致操作系統因為棧空間不足假死。
public class Main {
public static void main(String[] args) throws ClassNotFoundException {
CountDownLatch countDownLatch = new CountDownLatch(1);
for(int i =0;i<1020000000;i++){
new Thread(new Runnable(){
@Override
public void run() {
int a = 1000;
try {
countDownLatch.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
}
countDownLatch.countDown();
}
}
內存泄漏
內存泄漏memory leak，指程序在申請內存之后，無法釋放已申請的內存空間，一次內存泄漏危害可以忽略，多次memory leak將導致oom。
內存泄漏是指你向系統申請分配內存進行使用(new)，可是使用完了以后卻不歸還(delete)，結果你申請到的那塊內存你自己也不能再訪問（也許你把它的地址給弄丟了），而系統也不能再次將它分配給需要的程序。
jvm性能調優監控工具使用詳解該部分內容轉自：JVM性能調優監控工具jps、jstack、jmap、jhat、jstat、hprof使用詳解
jps(Java Virture Machine Process Status Tool)jps主要用來輸出JVM中運行的進程狀態信息。語法格式如下：
jps [options] [hostid]
如果不指定hostid就默認為當前主機或服務器。
命令行參數選項說明如下：
-q 不輸出類名、Jar名和傳入main方法的參數 -m 輸出傳入main方法的參數 -l 輸出main類或Jar的全限名 -v 輸出傳入JVM的參數
比如下面：
root@ubuntu:/# jps -m -l 2458 org.artifactory.standalone.main.Main /usr/local/artifactory-2.2.5/etc/jetty.xml 29920 com.sun.tools.hat.Main -port 9998 /tmp/dump.dat 3149 org.apache.catalina.startup.Bootstrap start 30972 sun.tools.jps.Jps -m -l 8247 org.apache.catalina.startup.Bootstrap start 25687 com.sun.tools.hat.Main -port 9999 dump.dat 21711 mrf-center.jarjstack
jstack主要用來查看某個Java進程內的線程堆棧信息。語法格式如下：
jstack [option] pid jstack [option] executable core jstack [option] [server-id@]remote-hostname-or-ip
命令行參數選項說明如下：
-l long listings，會打印出額外的鎖信息，在發生死鎖時可以用jstack -l pid來觀察鎖持有情況 -m mixed mode，不僅會輸出Java堆棧信息，還會輸出C/C++堆棧信息（比如Native方法）
jstack可以定位到線程堆棧，根據堆棧信息我們可以定位到具體代碼，所以它在JVM性能調優中使用得非常多。下面我們來一個實例找出某個Java進程中最耗費CPU的Java線程并定位堆棧信息，用到的命令有ps、top、printf、jstack、grep。
第一步先找出Java進程ID，我部署在服務器上的Java應用名稱為mrf-center：
root@ubuntu:/# ps -ef | grep mrf-center | grep -v grep root 21711 1 1 14:47 pts/3 00:02:10 java -jar mrf-center.jar
得到進程ID為21711，第二步找出該進程內最耗費CPU的線程，可以使用ps -Lfp pid或者ps -mp pid -o THREAD, tid, time或者top -Hp pid，我這里用第三個，輸出如下：
TIME列就是各個Java線程耗費的CPU時間，CPU時間最長的是線程ID為21742的線程，用
printf "%x " 21742
得到21742的十六進制值為54ee，下面會用到。
OK，下一步終于輪到jstack上場了，它用來輸出進程21711的堆棧信息，然后根據線程ID的十六進制值grep，如下：
root@ubuntu:/# jstack 21711 | grep 54ee "PollIntervalRetrySchedulerThread" prio=10 tid=0x00007f950043e000 nid=0x54ee in Object.wait() [0x00007f94c6eda000]
可以看到CPU消耗在PollIntervalRetrySchedulerThread這個類的Object.wait()，我找了下我的代碼，定位到下面的代碼：
// Idle wait
getLog().info("Thread [" + getName() + "] is idle waiting...");
schedulerThreadState = PollTaskSchedulerThreadState.IdleWaiting;
long now = System.currentTimeMillis();
long waitTime = now + getIdleWaitTime();
long timeUntilContinue = waitTime - now;
synchronized(sigLock) {
try {
if(!halted.get()) {
sigLock.wait(timeUntilContinue);
}
}
catch (InterruptedException ignore) {
}
}
它是輪詢任務的空閑等待代碼，上面的sigLock.wait(timeUntilContinue)就對應了前面的Object.wait()。
jmap（Memory Map）和jhat（Java Heap Analysis Tool）jmap用來查看堆內存使用狀況，一般結合jhat使用。
jmap語法格式如下：
jmap [option] pid jmap [option] executable core jmap [option] [server-id@]remote-hostname-or-ip
如果運行在64位JVM上，可能需要指定-J-d64命令選項參數。
jmap -permstat pid
打印進程的類加載器和類加載器加載的持久代對象信息，輸出：類加載器名稱、對象是否存活（不可靠）、對象地址、父類加載器、已加載的類大小等信息，如下圖：
使用jmap -heap pid查看進程堆內存使用情況，包括使用的GC算法、堆配置參數和各代中堆內存使用情況。比如下面的例子：
root@ubuntu:/# jmap -heap 21711 Attaching to process ID 21711, please wait... Debugger attached successfully. Server compiler detected. JVM version is 20.10-b01 using thread-local object allocation. Parallel GC with 4 thread(s) Heap Configuration: MinHeapFreeRatio = 40 MaxHeapFreeRatio = 70 MaxHeapSize = 2067791872 (1972.0MB) NewSize = 1310720 (1.25MB) MaxNewSize = 17592186044415 MB OldSize = 5439488 (5.1875MB) NewRatio = 2 SurvivorRatio = 8 PermSize = 21757952 (20.75MB) MaxPermSize = 85983232 (82.0MB) Heap Usage: PS Young Generation Eden Space: capacity = 6422528 (6.125MB) used = 5445552 (5.1932830810546875MB) free = 976976 (0.9317169189453125MB) 84.78829520089286% used From Space: capacity = 131072 (0.125MB) used = 98304 (0.09375MB) free = 32768 (0.03125MB) 75.0% used To Space: capacity = 131072 (0.125MB) used = 0 (0.0MB) free = 131072 (0.125MB) 0.0% used PS Old Generation capacity = 35258368 (33.625MB) used = 4119544 (3.9287033081054688MB) free = 31138824 (29.69629669189453MB) 11.683876009235595% used PS Perm Generation capacity = 52428800 (50.0MB) used = 26075168 (24.867218017578125MB) free = 26353632 (25.132781982421875MB) 49.73443603515625% used ....
使用jmap -histo[:live] pid查看堆內存中的對象數目、大小統計直方圖，如果帶上live則只統計活對象，如下：
root@ubuntu:/# jmap -histo:live 21711 | more num #instances #bytes class name ---------------------------------------------- 1: 38445 55977362: 38445 5237288 3: 3500 3749504 4: 60858 3242600 5: 3500 2715264 6: 2796 2131424 7: 5543 1317400 [I 8: 13714 1010768 [C 9: 4752 1003344 [B 10: 1225 639656 11: 14194 454208 java.lang.String 12: 3809 396136 java.lang.Class 13: 4979 311952 [S 14: 5598 287064 [[I 15: 3028 266464 java.lang.reflect.Method 16: 280 163520 17: 4355 139360 java.util.HashMap$Entry 18: 1869 138568 [Ljava.util.HashMap$Entry; 19: 2443 97720 java.util.LinkedHashMap$Entry 20: 2072 82880 java.lang.ref.SoftReference 21: 1807 71528 [Ljava.lang.Object; 22: 2206 70592 java.lang.ref.WeakReference 23: 934 52304 java.util.LinkedHashMap 24: 871 48776 java.beans.MethodDescriptor 25: 1442 46144 java.util.concurrent.ConcurrentHashMap$HashEntry 26: 804 38592 java.util.HashMap 27: 948 37920 java.util.concurrent.ConcurrentHashMap$Segment 28: 1621 35696 [Ljava.lang.Class; 29: 1313 34880 [Ljava.lang.String; 30: 1396 33504 java.util.LinkedList$Entry 31: 462 33264 java.lang.reflect.Field 32: 1024 32768 java.util.Hashtable$Entry 33: 948 31440 [Ljava.util.concurrent.ConcurrentHashMap$HashEntry;
class name是對象類型，說明如下：
B byte C char D double F float I int J long Z boolean [ 數組，如[I表示int[] [L+類名 其他對象
還有一個很常用的情況是：用jmap把進程內存使用情況dump到文件中，再用jhat分析查看。jmap進行dump命令格式如下：
jmap -dump:format=b,file=dumpFileName pid
我一樣地對上面進程ID為21711進行Dump：
root@ubuntu:/# jmap -dump:format=b,file=/tmp/dump.dat 21711 Dumping heap to /tmp/dump.dat ... Heap dump file created
dump出來的文件可以用MAT、VisualVM等工具查看，這里用jhat查看：
root@ubuntu:/# jhat -port 9998 /tmp/dump.dat Reading from /tmp/dump.dat... Dump file created Tue Jan 28 17:46:14 CST 2014 Snapshot read, resolving... Resolving 132207 objects... Chasing references, expect 26 dots.......................... Eliminating duplicate references.......................... Snapshot resolved. Started HTTP server on port 9998 Server is ready.
注意如果Dump文件太大，可能需要加上-J-Xmx512m這種參數指定最大堆內存，即jhat -J-Xmx512m -port 9998 /tmp/dump.dat。然后就可以在瀏覽器中輸入主機地址:9998查看了：
上面紅線框出來的部分大家可以自己去摸索下，最后一項支持OQL（對象查詢語言）。
jstat（JVM統計監測工具）語法格式如下：
jstat [ generalOption | outputOptions vmid [interval[s|ms] [count]] ]
vmid是Java虛擬機ID，在Linux/Unix系統上一般就是進程ID。interval是采樣時間間隔。count是采樣數目。比如下面輸出的是GC信息，采樣時間間隔為250ms，采樣數為4：
root@ubuntu:/# jstat -gc 21711 250 4 S0C S1C S0U S1U EC EU OC OU PC PU YGC YGCT FGC FGCT GCT 192.0 192.0 64.0 0.0 6144.0 1854.9 32000.0 4111.6 55296.0 25472.7 702 0.431 3 0.218 0.649 192.0 192.0 64.0 0.0 6144.0 1972.2 32000.0 4111.6 55296.0 25472.7 702 0.431 3 0.218 0.649 192.0 192.0 64.0 0.0 6144.0 1972.2 32000.0 4111.6 55296.0 25472.7 702 0.431 3 0.218 0.649 192.0 192.0 64.0 0.0 6144.0 2109.7 32000.0 4111.6 55296.0 25472.7 702 0.431 3 0.218 0.649
要明白上面各列的意義，先看JVM堆內存布局：
可以看出：
堆內存 = 年輕代 + 年老代 + 永久代 年輕代 = Eden區 + 兩個Survivor區（From和To）
現在來解釋各列含義：
S0C、S1C、S0U、S1U：Survivor 0/1區容量（Capacity）和使用量（Used） EC、EU：Eden區容量和使用量 OC、OU：年老代容量和使用量 PC、PU：永久代容量和使用量 YGC、YGT：年輕代GC次數和GC耗時 FGC、FGCT：Full GC次數和Full GC耗時 GCT：GC總耗時hprof（Heap/CPU Profiling Tool）
hprof能夠展現CPU使用率，統計堆內存使用情況。
語法格式如下：
java -agentlib:hprof[=options] ToBeProfiledClass java -Xrunprof[:options] ToBeProfiledClass javac -J-agentlib:hprof[=options] ToBeProfiledClass
完整的命令選項如下：
Option Name and Value Description Default --------------------- ----------- ------- heap=dump|sites|all heap profiling all cpu=samples|times|old CPU usage off monitor=y|n monitor contention n format=a|b text(txt) or binary output a file=write data to file java.hprof[.txt] net= : send data over a socket off depth= stack trace depth 4 interval= sample interval in ms 10 cutoff= output cutoff point 0.0001 lineno=y|n line number in traces? y thread=y|n thread in traces? n doe=y|n dump on exit? y msa=y|n Solaris micro state accounting n force=y|n force output to y verbose=y|n print messages about dumps y
來幾個官方指南上的實例。
CPU Usage Sampling Profiling(cpu=samples)的例子：
java -agentlib:hprof=cpu=samples,interval=20,depth=3 Hello
上面每隔20毫秒采樣CPU消耗信息，堆棧深度為3，生成的profile文件名稱是java.hprof.txt，在當前目錄。
CPU Usage Times Profiling(cpu=times)的例子，它相對于CPU Usage Sampling Profile能夠獲得更加細粒度的CPU消耗信息，能夠細到每個方法調用的開始和結束，它的實現使用了字節碼注入技術（BCI）：
javac -J-agentlib:hprof=cpu=times Hello.java
Heap Allocation Profiling(heap=sites)的例子：
javac -J-agentlib:hprof=heap=sites Hello.java
Heap Dump(heap=dump)的例子，它比上面的Heap Allocation Profiling能生成更詳細的Heap Dump信息：
javac -J-agentlib:hprof=heap=dump Hello.java
雖然在JVM啟動參數中加入-Xrunprof:heap=sites參數可以生成CPU/Heap Profile文件，但對JVM性能影響非常大，不建議在線上服務器環境使用。
垃圾收集器程序計數器、虛擬機棧和本地方法棧這三個區域屬于線程私有的，只存在于線程的生命周期內，線程結束之后也會消失，因此不需要對這三個區域進行垃圾回收。垃圾回收主要是針對 Java 堆和方法區進行。
判斷對象是否死亡 引用計數算法給對象添加一個引用計數器，每當有一個地方引用它，計數器值就加1；引用時效時，計算器值就減1；當計數器值為0的對象就是不可能再被使用的。
當兩個對象相互引用時，此時引用計數器的值永遠不為0，導致無法對它們進行垃圾回收。
public class ReferenceCountingGC {
public Object instance = null;
public static void testGC() {
ReferenceCountingGC objA = new ReferenceCountingGC();
ReferenceCountingGC objB = new ReferenceCountingGC();
objA .instance = objB ;
objB .instance = objA ;
objA = null;
objB = null;
System.gc();
}
}
可達性分析算法
以GC Roots為起始點，從這些節點開始向下搜索，能夠搜索到的對象都是存活的，不可達的對象則為不可用。
在Java語言中，可作為GC Roots的對象包括下面幾種：
虛擬機棧中引用的對象
方法區中靜態屬性引用的對象
方法區中常量引用的對象
本地方法棧中Native方法引用的對象
引用類型無論是引用計數算法還是可達性分析算法判斷對象是否存活都與引用有關。在JDK1.2之后，Java對引用的概念進行了擴充，劃分為強度不同的四個的引用類型。
強引用通過new來創建對象的引用類型，被強引用的對象永遠不會被垃圾收集器回收。
Object obj = new Object();軟引用
通過SortReference類來實現，只有在內存不足的時候才會被回收。
Object obj = new Object();
SoftReference
弱引用
通過WeakReference類來實現，只能存活到下一次垃圾收集發生之前。
Object obj = new Object();
WeakReference
WeakHashMap 的 Entry 繼承自 WeakReference，主要用來實現緩存。
private static class Entry
