JVM效能調優監控工具jps、jstack、jmap、jhat、jstat、hprof使用詳解
阿新 • • 發佈：2019-01-28
第一部分：工具介紹部分：
現實企業級Java開發中，有時候我們會碰到下面這些問題：
-
OutOfMemoryError，記憶體不足
-
記憶體洩露
-
執行緒死鎖
-
鎖爭用（Lock Contention）
-
Java程序消耗CPU過高
-
......
這些問題在日常開發中可能被很多人忽視（比如有的人遇到上面的問題只是重啟伺服器或者調大記憶體，而不會深究問題根源），但能夠理解並解決這些問題是Java程式設計師進階的必備要求。
A、 jps(Java Virtual 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 B、 jstack
jstack主要用來檢視某個Java程序內的執行緒堆疊資訊。語法格式如下：
jstack [option] pid
jstack [option] executable core
jstack 命令列引數選項說明如下：
-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的執行緒，可以使用 1）ps -Lfp pid 2）ps -mp pid -o THREAD, tid, time 3）top -Hp pid 用第三個，輸出如下：
TIME列就是各個Java執行緒耗費的CPU時間，CPU時間最長的是執行緒ID為21742的執行緒，用
printf "%x\n" 21742
得到21742的十六進位制值為54ee，下面會用到。
OK，下一步終於輪到jstack上場了，它用來輸出程序21711的堆疊資訊，然後根據執行緒ID的十六進位制值grep，如下：
root@ubuntu:/# jstack 21711 | grep 54ee
"PollIntervalRetrySchedulerThread" prio=10 tid=0x00007f950043e000 nid=0x54ee in Object.wait()可以看到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()。
C、 jmap（Memory Map）和jhat（Java Heap Analysis Tool）
jmap用來檢視堆記憶體使用狀況，一般結合jhat使用。
jmap語法格式如下：
jmap [option] pid
jmap [option] executable core
jmap [option] [[email protected]]remote-hostname-or-ip如果執行在64位JVM上，可能需要指定-J-d64命令選項引數。
jmap -permstat pid
列印程序的類載入器和類載入器載入的持久代物件資訊，輸出：類載入器名稱、物件是否存活（不可靠）、物件地址、父類載入器、已載入的類大小等資訊，如下圖：
使用jmap -heap pid檢視程序堆記憶體使用情況，包括使用的GC演算法、堆配置引數和各代中堆記憶體使用情況。 比如下面的例子
[email protected]:/# 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則只統計活物件，如下：
[email protected]:/# jmap -histo:live 21711 | more num #instances #bytes class name ---------------------------------------------- 1: 38445 5597736 <constMethodKlass> 2: 38445 5237288 <methodKlass> 3: 3500 3749504 <constantPoolKlass> 4: 60858 3242600 <symbolKlass> 5: 3500 2715264 <instanceKlassKlass> 6: 2796 2131424 <constantPoolCacheKlass> 7: 5543 1317400 [I 8: 13714 1010768 [C 9: 4752 1003344 [B 10: 1225 639656 <methodDataKlass> 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 <objArrayKlassKlass> 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 createddump出來的檔案可以用MAT、VisualVM等工具檢視，這裡用jhat檢視：
[email protected]:/# 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（物件查詢語言）。
D、 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總耗時
E、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=<file> write data to file java.hprof[.txt]
net=<host>:<port> send data over a socket off
depth=<size> stack trace depth 4
interval=<ms> sample interval in ms 10
cutoff=<value> 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 <file> y
verbose=y|n print messages about dumps y來幾個官方指南上的例項。
CPU Usage Sampling Profiling(cpu=samples)的例子：
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效能影響非常大，不建議在線上伺服器環境使用。
第二部分： 例項部分：
1、使用jstack來分析死鎖問題：
上面說明中提到jstack 是一個可以返回在應用程式上執行的各種各樣執行緒的一個完整轉儲的實用程式,您可以使用它查明問題。jstack [-l] <pid>,jpid可以通過使用jps命令來檢視當前Java程式的jpid值,-l是可選引數,它可以顯示執行緒阻塞/死鎖情況
/**
* Dead lock example
*
* @author Josh Wang(Sheng)
*
* @email josh_wang23@hotmail.com
*/
public class DeadLock2Live {
public static void main(String[] args) {
System.out.println(" start the example ----- ");
final Object obj_1 = new Object(), obj_2 = new Object();
Thread t1 = new Thread("t1"){
@Override
public void run() {
synchronized (obj_1) {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {}
synchronized (obj_2) {
System.out.println("thread t1 done.");
}
}
}
};
Thread t2 = new Thread("t2"){
@Override
public void run() {
synchronized (obj_2) {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {}
synchronized (obj_1) {
System.out.println("thread t2 done.");
}
}
}
};
t1.start();
t2.start();
}
}以上DeadLock類是一個死鎖的例子,假使在我們不知情的情況下,執行DeadLock後,發現等了N久都沒有在螢幕列印執行緒完成資訊。這個時候我們就可以使用jps檢視該程式的jpid值和使用jstack來生產堆疊結果問題。
java -cp deadlock.jar DeadLock &$ jps
3076 Jps
448 DeadLock
$ jstack -l 448 > deadlock.jstack結果檔案deadlock.jstack內容如下：
2014-11-29 13:31:06
Full thread dump Java HotSpot(TM) 64-Bit Server VM (24.65-b04 mixed mode):
"Attach Listener" daemon prio=5 tid=0x00007fd9d4002800 nid=0x440b waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
"DestroyJavaVM" prio=5 tid=0x00007fd9d4802000 nid=0x1903 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
"t2" prio=5 tid=0x00007fd9d30ac000 nid=0x5903 waiting for monitor entry [0x000000011da46000]
java.lang.Thread.State: BLOCKED (on object monitor)
at DeadLock$2.run(DeadLock.java:38)
- waiting to lock <0x00000007aaba7e58> (a java.lang.Object)
- locked <0x00000007aaba7e68> (a java.lang.Object)
Locked ownable synchronizers:
- None
"t1" prio=5 tid=0x00007fd9d30ab800 nid=0x5703 waiting for monitor entry [0x000000011d943000]
java.lang.Thread.State: BLOCKED (on object monitor)
at DeadLock$1.run(DeadLock.java:23)
- waiting to lock <0x00000007aaba7e68> (a java.lang.Object)
- locked <0x00000007aaba7e58> (a java.lang.Object)
Locked ownable synchronizers:
- None
"Service Thread" daemon prio=5 tid=0x00007fd9d2809000 nid=0x5303 runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
"C2 CompilerThread1" daemon prio=5 tid=0x00007fd9d304e000 nid=0x5103 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
"C2 CompilerThread0" daemon prio=5 tid=0x00007fd9d2800800 nid=0x4f03 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
"Signal Dispatcher" daemon prio=5 tid=0x00007fd9d3035000 nid=0x4d03 runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
"Finalizer" daemon prio=5 tid=0x00007fd9d2013000 nid=0x3903 in Object.wait() [0x000000011d18d000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000007aaa85608> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)
- locked <0x00000007aaa85608> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151)
at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:209)
Locked ownable synchronizers:
- None
"Reference Handler" daemon prio=5 tid=0x00007fd9d2012000 nid=0x3703 in Object.wait() [0x000000011d08a000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000007aaa85190> (a java.lang.ref.Reference$Lock)
at java.lang.Object.wait(Object.java:503)
at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:133)
- locked <0x00000007aaa85190> (a java.lang.ref.Reference$Lock)
Locked ownable synchronizers:
- None
"VM Thread" prio=5 tid=0x00007fd9d5011000 nid=0x3503 runnable
"GC task thread#0 (ParallelGC)" prio=5 tid=0x00007fd9d200b000 nid=0x2503 runnable
"GC task thread#1 (ParallelGC)" prio=5 tid=0x00007fd9d200b800 nid=0x2703 runnable
"GC task thread#2 (ParallelGC)" prio=5 tid=0x00007fd9d200c800 nid=0x2903 runnable
"GC task thread#3 (ParallelGC)" prio=5 tid=0x00007fd9d200d000 nid=0x2b03 runnable
"GC task thread#4 (ParallelGC)" prio=5 tid=0x00007fd9d200d800 nid=0x2d03 runnable
"GC task thread#5 (ParallelGC)" prio=5 tid=0x00007fd9d200e000 nid=0x2f03 runnable
"GC task thread#6 (ParallelGC)" prio=5 tid=0x00007fd9d200f000 nid=0x3103 runnable
"GC task thread#7 (ParallelGC)" prio=5 tid=0x00007fd9d200f800 nid=0x3303 runnable
"VM Periodic Task Thread" prio=5 tid=0x00007fd9d3033800 nid=0x5503 waiting on condition
JNI global references: 114
Found one Java-level deadlock:
=============================
"t2":
waiting to lock monitor 0x00007fd9d30aebb8 (object 0x00000007aaba7e58, a java.lang.Object),
which is held by "t1"
"t1":
waiting to lock monitor 0x00007fd9d28128b8 (object 0x00000007aaba7e68, a java.lang.Object),
which is held by "t2"
Java stack information for the threads listed above:
===================================================
"t2":
at DeadLock$2.run(DeadLock.java:38)
- waiting to lock <0x00000007aaba7e58> (a java.lang.Object)
- locked <0x00000007aaba7e68> (a java.lang.Object)
"t1":
at DeadLock$1.run(DeadLock.java:23)
- waiting to lock <0x00000007aaba7e68> (a java.lang.Object)
- locked <0x00000007aaba7e58> (a java.lang.Object)
Found 1 deadlock.
從這個結果檔案我們一看到發現了一個死鎖,具體是執行緒t2在等待執行緒t1,而執行緒t1在等待執行緒t2造成的,同時也記錄了執行緒的堆疊和程式碼行數,通過這個堆疊和行數我們就可以去檢查對應的程式碼塊,從而發現問題和解決問題。
可通過下面的程式碼解決死鎖問題：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* Dead lock example
*
* @author Josh Wang(Sheng)
*
* @email josh_wang23@hotmail.com
*/
public class DeadLock2Live {
public static void main(String[] args) {
System.out.println(" start the example ----- ");
final Lock lock = new ReentrantLock();
Thread t1 = new Thread("t1") {
@Override
public void run() {
try {
lock.lock();
Thread.sleep(3000);
System.out.println("thread t1 done.");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
};
Thread t2 = new Thread("t2") {
@Override
public void run() {
try {
lock.lock();
Thread.sleep(3000);
System.out.println("thread t2 done.");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
};
t1.start();
t2.start();
}
}2、繼續使用jstack來分析HashMap在多執行緒情況下的死鎖問題：
對於如下程式碼，使用10個執行緒來處理提交的2000個任務，每個任務會分別迴圈往hashmap中分別存入和取出1000個數，通過測試發現，程式並不能完整執行完成。[PS:該程式能不能成功執行完，有時也取決於所使用的伺服器的執行狀況，我在筆記本上測試的時候，大多時候該程式不能成功執行完成，後者會出現CPU轉速加快，發熱等情況]
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
*
*/
/**
* @author Josh Wang(Sheng)
*
* @email josh_wang23@hotmail.com
*/
public class HashMapDeadLock implements Callable<Integer> {
private static ExecutorService threadPool = Executors.newFixedThreadPool(10);
private static Map<Integer, Integer> results = new HashMap<>();
@Override
public Integer call() throws Exception {
results.put(1, 1);
results.put(2, 2);
results.put(3, 3);
for (int i = 0; i < 1000; i++) {
results.put(i, i);
}
Thread.sleep(1000);
for (int i= 0; i < 1000; i++) {
results.remove(i);
}
System.out.println(" ---- " + Thread.currentThread().getName() + " " + results.get(0));
return results.get(1);
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
try {
for (int i = 0; i < 2000; i++) {
HashMapDeadLock hashMapDeadLock = new HashMapDeadLock();
// Future<Integer> future = threadPool.submit(hashMapDeadLock);
// future.get();
threadPool.submit(hashMapDeadLock);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPool.shutdown();
}
}
}1） 使用jps檢視執行緒可得：
43221 Jps
30056
43125 HashMapDeadLock2）使用jstack匯出多執行緒棧區資訊：
jstack -l 43125 > hash.jstack
3) hash.jstack的內容如下：
2014-11-29 18:14:22
Full thread dump Java HotSpot(TM) 64-Bit Server VM (24.65-b04 mixed mode):
"Attach Listener"