1. 原來jdk自帶了這么好玩的工具——使用 jstack定位死循環
線程快照是java虛擬機內每一個線程正在執行的方法堆棧的集合，生成線程快照的主要目的是用於定位線程出現問題的位置；常見的問題有
命令格式
jstack的option參數並不多，真正用到的也就三個，接下來我們一個個介紹一下
- -F ：當線程掛起(Suspended)時，使用jstack -l pid命令是不會列印堆棧信息的，使用-F則可以強制輸出線程堆棧；但是會停止但
- -l ：列印的信息除了堆棧外，還會顯示鎖芹梁返的附加信息；
- -m ：同時輸出java和C/C++的堆棧信息；在java的系統類庫裡面，有很多方法都是native修飾的，這些native修飾的方法你在java層面是看不到源碼的，因為這些方法都是C/C++實現嫌飢的；
在線程的堆棧中，需要特別留意以下幾種狀態：
不帶option參數的命令
列印結果如下
第一行各個單詞的解析，
這里我們使用2個窗口，分別使用以下2個命令來測試
通過2個窗口對比可以看到，加了-l的命令多列印了鎖的信息；
一般情況下，如果程序出錯了， 都不會直接在生產環境的伺服器上找錯誤，這個時候就可以用到一個非常實用的功能，將堆棧快照導出來，然後到別的電腦上看，命令如下
執行後，就可以看到文件已經導出來了
通過cat命令可以看到，裡面的內容和我們在命令行輸出的內容是一樣的
首先我們准備好一個死循環的線程，在線程內定一個while的死循環，並且給這個線程起個名字為：yexindogn，阿里巴巴的開發規范裡面有一個規定，就是每個線程必須起一個名字，起名字就是為了 以後程序出問題的時候好找錯誤；
接著我們將此代碼打成jar包扔到linux伺服器上運行，直接輸入 java -jar Test.jar 命令即可運行，運行後我們可以看到控制台一直在輸出112這個字元，這就代表程序已經在運行了；
接著在看下CPU的運行情況，使用top命令查看cpu佔用情況，排在第一位的是進程號為30328的進程，佔用了6.6%的cpu； 這邊我使用了2個命令行連到同一台伺服器，一個窗口用來運行剛剛的jar包，另一個窗口用來查找錯誤；
知道進程號了，接著就是找線程了，輸入以下命令
列印結果如下，這里有一點需要注意，在我們加上-Hp指令後，PID展示就是線程的id了，這時候我們看到佔用CPU最高的線程id是30365；
還有另一種方式，就是使用ps命令來查找線程
通過這個命令我們可以看到這邊佔用最高的線程id也是30365 ;
以上的方式我們成功找到了佔用cpu高的線程id是30365，但這個id是十進制的，在這里需要先轉為16進制，輸入命令
計算出對應的16進制為：769d
當然也可以用其他的計算工具，比如mac系統自帶計算器就支持進制之間的轉換
在命令行輸入以下命令，這種方法更加快速，推薦使用
其中，grep 命令是查找結果為769d的內容，-A 20 表示列印匹配所在行的後20行內容。直接幫我們定位到所在線程的堆棧，結果如下
當然也可以用下面的死辦法，先列印出所有的堆棧快照；
列印結果如下
接著我用剛剛計算出來的16進制復制出來在這里搜索一下，經過查看就知道是我們剛剛起了名字為yexindong的線程出錯了，出錯的位置在Test.java的第13行代碼
我們看看java代碼，確實是第13行這里的死循環導致的
首先打開任務管理器，因為默認windows的任務管理器是不顯示進程pid的，所以我們需要設置一下，選擇 查看 選擇列(S)...
選中PID進程表示符後點擊確定按鈕
然後我們就可以看到佔用CPU最高的java進程PID為：976
因為windows不能直接查看java進程中的線程信息，所以我們需要藉助一個工具，渣指這個工具是微軟自己開發的，叫做Process Explorer ，網上很多，需要的童鞋請自行網路，打開後找到pid為976的進程右擊選擇 屬性
在彈出的窗口中找到線程這一欄，它的排序默認就是按照cpu佔用的率倒序排列的，所以最上面的就是佔用cpu最高的線程了，記住它的線程id：3548
剛剛拿到的進程id是十進制的，但是我們導出的jstack信息裡面，線程id是以16進制來展示的，所以我們要先將這個線程id為3548轉為16進制的，使用windows自帶的計算器即可，在快捷命令行輸入calc
計算器打開後將其設置為程序員使用的計算器
接著輸入線程id3548，在按一下16進制，就會自動進行轉換，結果為ddc，記住這個16進制；
在命令行輸入以下指令導出進程的堆棧快照信息
幾秒鍾後，快照導出了，靜靜地躺在文件夾里，等待著我們打開
用Notepad++打開導出的文件，搜索剛剛計算出來的16進制ddc，就可以定位到線程出錯的位置了
有些童鞋可能會覺得用這個jstack命令麻煩了，那java在代碼裡面可不可以列印出堆棧呢？你別說，還真有，就是這個方法：Thread.getAllStackTraces()；光說不練假把式，來個demo測試一下吧
執行後列印結果如下，由此可以看到，將當前進程的所有線程都列印出來了，但是這邊只列印了簡單的堆棧信息，對於開發人員來說，已經起到了監控作用；
作為調優和找錯的工具來說，可以說jstack是用的最多的一個工具了，但是由於局限性，現在已經慢慢被替換掉了；大家更傾向於使用阿里巴巴開發的工具arthas；感興趣的童鞋可以了解下！
2. 通過top和jstack確定哪些線程耗盡了CPU這些線程在做什麼
背景
有時，線上集群load會突然飆升，無法響應正常請求。
那麼引起load飆升的線程究竟在做什麼？哪些線程霸佔了CPU？可以通過top和jstack命令進行定位。
2. 定位步驟
1. 使用終端1進入目標機器，執行top命令，默認是進程視圖，其中PID是進程號，截圖如下：
在這里，我們只能看到java進程佔用CPU達到115%，那麼究竟是那些線程非常耗CPU呢？
2. 由於我們要看到線程，在終端1，按下「H」鍵或者「shift+h」，top視圖會切換到線程視圖，其中PID是線程號，截圖如下：
可以發現紅框內的線程的CPU使用率非常高，佔用CPU時間達燃賣到1秒左右，顯然不正常，但是這些線程在做什麼？
3.
打開終端2，使用舉姿jstack命令輸出這一時刻的線程棧，保存到文件，命名為jstack.log。注意：輸出線程棧和保存top命令快照盡量同時進行。
4. 由於jstack.log文件記錄的線程ID是16進制，需要將top命令展示的線程號轉換為16進制，以15100為皮答逗例，在linux下輸入命令：printf 0x%x 15100，得到15100的十六進制為0x3afc
5. 在jstack.log中搜索0x3afc關鍵字，可以清晰看到該線程在做刷新地址列表，如下圖：
3. 總結
以前碰到集群load飆升時，有時會束手無策，不知從何查起。以後再發生類似問題時，可以使用這個方法，看下究竟是那些線程在長時間佔用CPU，盡快定位問題和解決問題。
3. jstack 分析出線程id 如何找到進程嗎
jstack 分析出線程id 如何找到進程
jstack用於列印出給定的java進程ID或core file或遠程調試服務的Java堆棧信息。
如果是在64位機器上，需要指定選項"-J-d64"，Windows的jstack使用方式只支持以下的這種方式：jstack [-l] pid
如果java程序崩潰生成core文件，jstack工具可以用來獲得core文件的java stack和native stack的信息，從而可以輕松地知道java程序是如何崩潰和在程序何處發生問題。
另外，jstack工具還可以附屬到正在運行的java程序中，看到當時運行的java程序的java stack和native stack的信息, 如果現在運行的java程序呈現hung的狀態，jstack是非常有用的。
需要注意的問題:
l 不同的 JAVA虛機的線程 DUMP的創建方法和文件格式是不一樣的，不同的 JVM版本， mp信息也有差別。
l 在實際運行中，往往一次 mp的信息，還不足以確認問題。建議產生三次 mp信息，如果每次 mp都指向同一個問題，我們才確定問題的典型性。
2、命令格式
$jstack [ option ] pid
$jstack [ option ] executable core
$jstack [ option ] [server-id@]remote-hostname-or-IP
參數說明:
pid: java應用程序的進程號,一般可以通過jps來獲得;
executable:產生core mp的java可執行程序;
core:列印出的core文件;
remote-hostname-or-ip:遠程debug伺服器的名稱或IP;
server-id: 唯一id,假如一台主機上多個遠程debug服務;
示例:
$jstack –l 23561
線程分析:
一般情況下，通過jstack輸出的線程信息主要包括：jvm自身線程、用戶線程等。其中jvm線程會在jvm啟動時就會存在。對於用戶線程則是在用戶訪問時才會生成。
4. JDK命令介紹
命令jps用於列出java進程，直接運行jps不加任何參數，可以列出Java程序的進程ID以及Main函數等名稱。
參數-q指定jps只輸出進程ID，而不輸出類的短名稱
參數-m用於輸出傳遞給Java進程（主函數）的參數
參數 -l用於輸出主函數的完整路徑
參數 -v可以顯示傳遞給JVM的參數
jstat是一個可以用於觀察Java應用程序運行時信息的工具。它的功能非常強大，可以通過它，查看堆信息的詳細使用情況。主要用於監控虛擬機的各種運行狀態信息，如類的裝載、內存、垃圾回收、JIT編譯器等，在沒有GUI的伺服器上，這款工具是首選的一款監控工具。
基本使用語法為：
選項option可以由以下值構成：
-class：顯示ClassLoader的相關信息。
-compiler：顯示JIT編譯的相關信息。
-gc：顯示與GC相關的堆信息。
-gccapacity：顯示各個代的容量及使用情況。
-gccause：顯示垃圾收集相關信息（同-gcutil），同時顯示最後一次或當前正在發生的垃圾收集的誘發原因。
-gcnew：顯示新生代信息。
-gcnewcapacity：顯示新生代大小與使用情況。
-gcold：顯示老年代與永久代的信息。
-gcoldcapacity：顯示老年代的大小。
-gcmetacapacity：顯示元空間的大小。（在java8之前是使用-gcpermcapacity顯示永久代的大小）
-gcutil：顯示垃圾收集信息。
-printcompilation：輸出JIT編譯的方法信息。
以上選項可以輸入 jstat -options 查看。
-t 參數可以在輸出信息前加一個 Timestamp 列，顯示程序的運行時間。
-h 參數可以在周期性數據輸出時，輸出多少行數據後，跟著輸出一個表頭信息。
vmid 參數就是Java進程id。
interval 參數用於指定輸出統計數據的周期，單位為毫秒。
count 用於指定一共輸出多少次數據。
jinfo 可以用來查看正在運行的Java運行程序的擴展參數，甚至支持在運行時修改部分參數。可以用來查看正在運行的 java 應用程序的擴展參數，包括Java System屬性和JVM命令行參數；也可以動態的修改正在運行的 JVM 一些參數。當系統崩潰時，jinfo可以從core文件裡面知道崩潰的Java應用程序的配置信息。
jmap 可以生成Java應用程序的堆快照和對象的統計信息。基本語法為：
option 選項如下：
-mp 生成java堆轉儲快照。格式為： -mp:[live,]format=b,file=,其中live子參數說明是否只mp出存活的對象
-finalizerinfo 顯示在F-Queue中等待Finalizer線程執行finalize方法的對象。只在Linux/Solaris平台下有效
-heap 顯示java堆詳細信息，如使用哪種收集器、參數配置、分代情況等，在Linux/Solaris平台下有效
-histo 顯示堆中對象統計信息，包含類、實例對象、合集容量
-permstat 以ClassLoader為統計口徑顯示永久代內存狀態。只在Linux/Solaris平台下有效
-F 當虛擬機進程對-mp選項沒有相應時。可使用這個選項強制生成mp快照。只在Linux/Solaris平台下有效
使用 jhat 工具可以用於分析Java應用程序的堆快照內容。jhat 在分析完成後，使用HTTP伺服器展示其分析結果。在瀏覽器中訪問 http://localhost:7000/
jstack 可用於導出Java應用程序的線程堆棧。語法為：
-l選項用於列印鎖的附加信息。
jstack 工具會在控制台輸出程序中所有的鎖信息，可以使用重定向將輸出保存到文件。
通過 jstack 工具不僅可以得到線程堆棧，它還能自動進行死鎖檢查，輸出找到的死鎖信息。
之前所述的工具中，只涉及到監控本機的Java應用程序。而在這些工具中，一些監控工具也支持對遠程計算機的監控（如：jps、jstat）。為了啟用遠程監控，則需要配合使用jstatd工具。
命令jstatd是一個RMI服務端程序，它的作用相當於代理伺服器，建立本地計算機與遠程監控工具的通信。jstatd伺服器將本機的Java應用程序信息傳遞到遠程計算機。
JConsole（Java Monitoring and ManagementConsole）工具時JDK自帶的圖形化性能監控工具。通過JConsole工具，可以查看Java應用程序的運行概況，監控堆信息、永久區使用情況、類載入情況等。
5. 監控tomcat內存線程數
可以使用以下方式監控 Tomcat 內存和搜核喚線程數：
監控 Tomcat 進程的內存使用情況，可以使用系統工具如 top（Linux/Unix）或 Task Manager（Windows），或者使用第三方監控工具如 jstat, jmap, VisualVM 等。
監控 Tomcat 線程數，可以使用 jstack 命令獲取線程信息，然後統計線程數。例如，在 Linux/Unix 系統中，可以使用以下命令獲取 Tomcat 進程的線程信息：
jstack -l <pid> | grep "java.lang.Thread.State" | wc -l
其中 <pid> 是 Tomcat 進程的進程號。該世凱命令會輸出當前 Tomcat 進程中的線程數。
另外，也可以使用 Tomcat 內置的管理工具來監控內存和線程數。例如，在 Tomcat 8 或以上版本中，可以使用 Tomcat 自帶的 Manager App 來監控 Tomcat 內存和線程數。在 Manager App 的首頁上，可以看到 Tomcat 當前的內存使用情況和活動線程數。如果需要更詳細的信息，可以點擊頁面上的 Server Status 或 Thread Pool 鏈接氏銷，查看更詳細的信息。
6. cmd查看java進程命令
jstack命令。在cmd中，利用jstack命令可以查看java的全部進程並棗並兄對其進行修改。cmd稱為Windows命令處理器，有時也被稱為蔽行命令shell或cmd提示符，命令提示符即cmd.exe，是一個32位的命令行程序，微軟Windows系統基於Windows上的命令解釋程序，類似於微軟的DOS操作凳襲系統。
7. 利用 jstack 分析 mp文件
知識點：
1.Linux 的命令 vmstat l，查慎念看上下文切換次數 ， cs 表示 content switch
2.jstack pid 查看 默認 進歷凳程的mp 文件 ，
1）用 jps 查肢孝旅看 我們運行的項目pid，然後 jstack pid > 文件
2）grep java.lang.Thread.State m17|awk '{print $2$3$4$5}'|sort|uniq -c
3）vim 查詢相關字元串 ，用小字母的n,可以查看下一個匹配的字元串
4）確定問題症狀後，再分析。
8. 怎樣使用jstack診斷Java應用程序故障
1. 首先來了解一下jstack這個命令的作用,jstack 是一個可以敏慧返回在應用程序上運行的各種各樣線程的一個完整轉儲的實用程序,您可以使用它查明問題。jstack [-l] <pid>,jpid可以通過使用jps命令來查看當前Java程序的jpid值,-l是可選參數,它可以顯示線程阻塞/死鎖情況。
/**
* 死鎖例子
* @author crane.ding
* @since 2011-3-20
*/
public class DeadLock {
public static void main(String[] args) {
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();
}
}
2. 以上DeadLock類是一個死鎖的例子,假使在不知情的情況下,運行DeadLock後,發現等了N久廳穗都沒有在屏幕列印線程完成信息。這個時候就可以使用jps查看該程序的扮拿卜jpid值和使用jstack來生產堆棧結果問題。
$ java -cp deadlock.jar DeadLock &
$
$ jps
3076 Jps
448 DeadLock
$ jstack -l 448 > deadlock.jstack
結果文件deadlock.jstack內容如下：
2011-03-20 23:05:20
Full thread mp Java HotSpot(TM) Client VM (19.1-b02 mixed mode, sharing):
"DestroyJavaVM" prio=6 tid=0x00316800 nid=0x9fc waiting on condition [0x00000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
"t2" prio=6 tid=0x02bcf000 nid=0xc70 waiting for monitor entry [0x02f6f000]
java.lang.Thread.State: BLOCKED (on object monitor)
at com.demo.DeadLock$2.run(DeadLock.java:40)
- waiting to lock <0x22a297a8> (a java.lang.Object)
- locked <0x22a297b0> (a java.lang.Object)
Locked ownable synchronizers:
- None
"t1" prio=6 tid=0x02bce400 nid=0xba0 waiting for monitor entry [0x02f1f000]
java.lang.Thread.State: BLOCKED (on object monitor)
at com.demo.DeadLock$1.run(DeadLock.java:25)
- waiting to lock <0x22a297b0> (a java.lang.Object)
- locked <0x22a297a8> (a java.lang.Object)
Locked ownable synchronizers:
- None
"Low Memory Detector" daemon prio=6 tid=0x02bb9400 nid=0xa6c runnable [0x00000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
"CompilerThread0" daemon prio=10 tid=0x02bb2800 nid=0xcb8 waiting on condition [0x00000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
"Attach Listener" daemon prio=10 tid=0x02bb1000 nid=0x7f4 waiting on condition [0x00000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
"Signal Dispatcher" daemon prio=10 tid=0x02bd2800 nid=0xd80 runnable [0x00000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
"Finalizer" daemon prio=8 tid=0x02bab000 nid=0xe1c in Object.wait() [0x02d3f000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x229e1148> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:118)
- locked <0x229e1148> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:134)
at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:159)
Locked ownable synchronizers:
- None
"Reference Handler" daemon prio=10 tid=0x02ba6800 nid=0xbe0 in Object.wait() [0x02cef000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x229e1048> (a java.lang.ref.Reference$Lock)
at java.lang.Object.wait(Object.java:485)
at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:116)
- locked <0x229e1048> (a java.lang.ref.Reference$Lock)
Locked ownable synchronizers:
- None
"VM Thread" prio=10 tid=0x02b6a400 nid=0x568 runnable
"VM Periodic Task Thread" prio=10 tid=0x02bc8400 nid=0x75c waiting on condition
JNI global references: 878
Found one Java-level deadlock:
=============================
"t2":
waiting to lock monitor 0x02baaeec (object 0x22a297a8, a java.lang.Object),
which is held by "t1"
"t1":
waiting to lock monitor 0x02baa2bc (object 0x22a297b0, a java.lang.Object),
which is held by "t2"
Java stack information for the threads listed above:
===================================================
"t2":
at com.demo.DeadLock$2.run(DeadLock.java:40)
- waiting to lock <0x22a297a8> (a java.lang.Object)
- locked <0x22a297b0> (a java.lang.Object)
"t1":
at com.demo.DeadLock$1.run(DeadLock.java:25)
- waiting to lock <0x22a297b0> (a java.lang.Object)
- locked <0x22a297a8> (a java.lang.Object)
Found 1 deadlock.
3.從這個結果文件看到發現了一個死鎖,具體是線程t2在等待線程t1,而線程t1在等待線程t2造成的,同時也記錄了線程的堆棧和代碼行數,通過這個堆棧和行數就可以去檢查對應的代碼塊,從而發現問題和解決問題。
9. kill-3生成的線程堆棧怎麼查看
第一步：在終端運行Java程序
第二步：通過命令 pidof java 找到已經啟動的java進程的ID，選擇需要查看的java程序的進程ID
第三步：使用命令 kill -3 <java進行的 pid> 列印出java程序的線程堆棧信息
第四步：通常情況下運行的項目可能會比較大，那麼這個時候列印的堆棧信息可能會有幾千到幾萬行，為了方便查看，我們往往需要將輸出內容進行重定向
使用linux下的重定向命令方式即可：例如： demo.sh > run.log 2>&1 將輸出信息重定向到 run.log中。
註：在操作系統中，0 1 2分別對應著不同的含義， 如下：
0 ： 標准輸入，即：C中的stdin ， java中的System.in
1 ： 標准輸出， 即：C中的stdout ，java中的System.out
2 ： 錯誤輸出， 即：C中的stderr ， java中的System.err
Demo：
----------------------------------------------------------------------------------------------
Sources Code ：
public class PrintThreadTrace {
Object obj1 = new Object();
Object obj2 = new Object();
public void func1(){
synchronized (obj1){
func2();
}
}
public void func2(){
synchronized (obj2){
while(true){
System.out.print("");
}
}
}
public static void main(String[] args){
PrintThreadTrace ptt = new PrintThreadTrace();
ptt.func1();
}
}
----------------------------------------------------------------------------------------------------------------
按照步驟操作後的列印輸出信息：
Full thread mp Java HotSpot(TM) 64-Bit Server VM (24.79-b02 mixed mode):
"Service Thread" daemon prio=10 tid=0x00007fdc880a9000 nid=0x12a4 runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"C2 CompilerThread1" daemon prio=10 tid=0x00007fdc880a7000 nid=0x12a3 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"C2 CompilerThread0" daemon prio=10 tid=0x00007fdc880a4000 nid=0x12a2 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"JDWP Command Reader" daemon prio=10 tid=0x00007fdc50001000 nid=0x1299 runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"JDWP Event Helper Thread" daemon prio=10 tid=0x00007fdc880a1800 nid=0x1298 runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"JDWP Transport Listener: dt_socket" daemon prio=10 tid=0x00007fdc8809e000 nid=0x1297 runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"Signal Dispatcher" daemon prio=10 tid=0x00007fdc88091000 nid=0x1296 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"Finalizer" daemon prio=10 tid=0x00007fdc88071800 nid=0x1295 in Object.wait() [0x00007fdc77ffe000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000000ecb04858> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)
- locked <0x00000000ecb04858> (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)
"Reference Handler" daemon prio=10 tid=0x00007fdc8806f800 nid=0x1294 in Object.wait() [0x00007fdc7c10b000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000000ecb04470> (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 <0x00000000ecb04470> (a java.lang.ref.Reference$Lock)
"main" prio=10 tid=0x00007fdc8800b800 nid=0x128e runnable [0x00007fdc8fef7000]
java.lang.Thread.State: RUNNABLE
at com.wenchain.study.PrintThreadTrace.func2(PrintThreadTrace.java:20)
- locked <0x00000000ecc04b20> (a java.lang.Object)
at com.wenchain.study.PrintThreadTrace.func1(PrintThreadTrace.java:13)
- locked <0x00000000ecc04b10> (a java.lang.Object)
at com.wenchain.study.PrintThreadTrace.main(PrintThreadTrace.java:27)
"VM Thread" prio=10 tid=0x00007fdc8806b000 nid=0x1293 runnable
"GC task thread#0 (ParallelGC)" prio=10 tid=0x00007fdc88021000 nid=0x128f runnable
"GC task thread#1 (ParallelGC)" prio=10 tid=0x00007fdc88023000 nid=0x1290 runnable
"GC task thread#2 (ParallelGC)" prio=10 tid=0x00007fdc88024800 nid=0x1291 runnable
"GC task thread#3 (ParallelGC)" prio=10 tid=0x00007fdc88026800 nid=0x1292 runnable
"VM Periodic Task Thread" prio=10 tid=0x00007fdc880b3800 nid=0x12a5 waiting on condition
JNI global references: 1391
Heap
PSYoungGen total 17920K, used 1270K [0x00000000ecb00000, 0x00000000ede80000, 0x0000000100000000)
eden space 15872K, 8% used [0x00000000ecb00000,0x00000000ecc3d898,0x00000000eda80000)
from space 2048K, 0% used [0x00000000edc80000,0x00000000edc80000,0x00000000ede80000)
to space 2048K, 0% used [0x00000000eda80000,0x00000000eda80000,0x00000000edc80000)
ParOldGen total 39424K, used 0K [0x00000000c6200000, 0x00000000c8880000, 0x00000000ecb00000)
object space 39424K, 0% used [0x00000000c6200000,0x00000000c6200000,0x00000000c8880000)
PSPermGen total 21504K, used 2619K [0x00000000c1000000, 0x00000000c2500000, 0x00000000c6200000)
object space 21504K, 12% used [0x00000000c1000000,0x00000000c128edd8,0x00000000c2500000)
----------------------------------------------------------------------------------------------------------------------------
上面的信息中包含了當前JVM中所有運行的線程信息，其中在示例中我們啟動的線程為main線程，其餘的都是JVM自己創建的。
在列印的信息中，我們可以清楚的看見當前線程的調用上下文，可以很清楚的知道程序的運行情況。
並且我們在最後面還能看見當前虛擬機中的內存使用情況，青年世代，老年世代的信息等等...
PS: 在JDK1.5以上，我們可以通過在Java程序中調用Thread.getStackTrace()方法來進行堆棧的自動列印，使得線程堆棧的列印時機可編程控制。
文章知識點與官方知識檔案匹配
Java技能樹首頁概覽
89841 人正在系統學習中
點擊閱讀全文
打開CSDN，閱讀體驗更佳
jstack-查看Java進程的線程堆棧信息,鎖定高消耗資源代碼
jstack主要用來查看某個Java進程內的線程堆棧信息。語法格式如下: jstack[option]pid jstack[option]executable core jstack[option][server-id@]remote-hostname-or-ip 命令行參數選項說明如下: ...
011Java並發包018查看線程堆棧信息_執筆未來的博客
java.util.concurrent.ScheledThreadPoolExecutor$DelayedWorkQueue.take(ScheledThreadPoolExecutor.java:1088) java.util.concurrent.ScheledThreadPoolExecutor$DelayedWorkQueue.take(ScheledThreadPoolExecutor.java:809) java.util.concurre...
最新發布 jstack -- java堆棧常用排查指令
jstack -- java堆棧常用排查指令
繼續訪問
熱門推薦 jstack 命令查看JAVA線程堆棧
JAVA堆棧信息實際生產中，可能由於開發以及測試未能全面覆蓋的代碼質量、性能問題，而引致線程掛起甚至崩潰。可能就需要查看堆棧信息來排查問題了。jps -lvmjps -lvm 用於查看當前機器上運行的java進程。C:\Users\Administrator>jps -lvm 7348 -Dosgi.requiredJavaVersion=1.8 -Dosgi.instance.area.defa
繼續訪問
Java多線程——查看線程堆棧信息
Java多線程——查看線程堆棧信息 摘要：本文主要介紹了查看線程堆棧信息的方法。 使用Thread類的getAllStackTraces()方法 方法定義 可以看到getAllStackTraces()方法的返回值是一個Map對象，key是Thread的實例，value是一個StackTraceElement實例數組： 1 public static Map<Thread, S...
繼續訪問
java堆棧常用排查指令
java 異常排查四板斧 1、查看java 堆棧線程信息 說明 jstack命令列印指定Java進程、核心文件或遠程調試伺服器的Java線程的Java堆棧跟蹤信息。 對於每個Java框架，完整的類名，方法名， 位元組碼索引(BCI)和行號(如果有的話)被列印出來。 使用-m選項，jstack命令列印程序中所有線程的Java和本機幀 計數器(PC)。 對於每個本機幀，當可用時，將列印離PC最近的本機符號。 c++亂碼的名字不會被修改。 要demangle c++名稱，輸出這個 命令可以管道到c++filt。 當
繼續訪問
java診斷工具-Arthas（thread命令）查看當前線程堆棧
cpu使用率與linux 命令top -H -p <pid>的線程CPU類似 1、支持一鍵展示當前最忙的前N個線程並列印堆棧 thread -n 3 沒有線程ID，包含[Internal]表示為JVM內部線程，參考dashboard命令的介紹。 cpuUsage為采樣間隔時間內線程的CPU使用率，與dashboard命令的數據一致。 deltaTime為采樣間隔時間內線程的增量CPU時間，小於1ms時被取整顯示為0ms。 time線程運行總CPU...
繼續訪問
java查看線程的堆棧信息
通過使用jps 命令獲取需要監控的進程的pid，然後使用jstackpid 命令查看線程的堆棧信息。 通過jstack命令可以獲取當前進程的所有線程信息。 每個線程堆中信息中，都可以查看到線程ID、線程的狀態（wait、sleep、running 等狀態）、是否持有鎖信息等。 jstack -l <pid> >jvm_listlocks.txt 轉...
繼續訪問
java 查看線程堆棧信息_Java多線程——查看線程堆棧信息
java多線程——查看線程堆棧信息摘要：本文主要介紹了查看線程堆棧信息的方法。使用thread類的getallstacktraces()方法方法定義可以看到getallstacktraces()方法的返回值是一個map對象，key是thread的實例，value是一個stacktraceelement實例數組：1 public static map getallstacktraces()使用可以使...
繼續訪問
java線程堆棧信息分析
java堆棧信息分析
繼續訪問
java 查看堆棧_javap 命令查看堆棧中信息
javap命令是對.java文件進行反編譯，通過這個命令可以看到堆棧中是怎麼壓棧和出棧的已經執行順序，這里簡單解釋下javap的簡單的使用，下面舉個例子：題目：i++ 和++i的區別解釋：簡單點說 這個問題都不難回答，這里就不說了，但是實際上堆棧中區別也是老大了(這里就用到了javap命令)， 步驟：1.在任意一個盤下面建一個名為Test.java的文件(文件名可以隨意命名)代碼如下：public...
繼續訪問
java 查看線程堆棧信息_jstack-查看Java進程的線程堆棧信息，鎖定高消耗資源代碼。...
jstack主要用來查看某個Java進程內的線程堆棧信息。語法格式如下：jstack[option]pidjstack[option]executablecorejstack[option][server-id@]remote-hostname-or-ip命令行參數選項說明如下：-llonglistings，會列印出額外的鎖信息，在發生死鎖時可以用jstack-lpid來觀察...
繼續訪問
java堆棧信息怎麼看_線程堆棧信息怎麼看？ - cs_person的個人空間 - OSCHINA - 中文開源技術交流社區...
一條線程堆棧信息大概長成下面這個樣子：RMI TCP Connection(267865)-172.16.5.25" daemon prio=10 tid=0x00007fd508371000 nid=0x55ae waiting for monitor entry [0x00007fd4f8684000]java.lang.Thread.State: BLOCKED (on object m...
繼續訪問
線程堆棧信息怎麼看？
一條線程堆棧信息大概長成下面這個樣子： RMI TCP Connection(267865)-172.16.5.25" daemon prio=10 tid=0x00007fd508371000 nid=0x55ae waiting for monitor entry [0x00007fd...
繼續訪問
java的棧和堆
棧與堆都是Java用來在Ram中存放數據的地方。與C++不同，Java自動管理棧和堆，程序員不能直接地設置棧或堆。 Java 的堆是一個運行時數據區,類的(對象從中分配空間。這些對象通過new、newarray、anewarray和multianewarray等指令建立，它們不需要程序代碼來顯式的釋放。堆是由垃圾回收來負責的，堆的優勢是可以動態地分配內存大小，生存期也不必事先告訴編譯器，因為它是在...
繼續訪問
查看java線程_【JAVA】Java線程堆棧信息查看
如何獲得線程的堆棧信息？線上伺服器cpu 100%了，該如何排查問題？1.top命令查詢哪個pid進程佔用cpu高(ps -ef|grep java 獲取PID號)2.通過 top -Hp pid 可以查看該進程下各個線程的cpu使用情況,獲取佔用cpu高的線程id3.執行命令：printf "%X\n" 線程tid(用於獲取佔用cpu高的線程id的16進制數)4.執行命令：jstack pid ...
繼續訪問
kill -3 java_kill -3 PID命令獲取java應用堆棧信息
一、應用場景：當linux伺服器出現異常情況(響應緩慢，負載持續飆升)並且伺服器沒有安裝對應的包而無法使用jstack等命令時，可以使用linux的kill相關命令列印堆棧信息。命令格式：kill -3 PID二、執行步驟：2.1、獲取java進程的PIDps -ef|grep java結果的第二列數字就是進程對應的pid。2.2、kill -3 PID(1)如果項目通過Tomcat進行發布(普通...
繼續訪問
jstack 工具 查看JVM堆棧信息
1|0介紹 jstack是java虛擬機自帶的一種堆棧跟蹤工具。jstack用於列印出給定的java進程ID或corefile或遠程調試服務的Java堆棧信息，如果是在64位機器上，需要指定選項"-J-d64"，Windows的jstack使用方式只支持以下的這種方式： jstack [-l] pid 主要分為兩個功能： a． 針對活著的進程做本地的或遠程的線程mp； b． 針對core文件做線程mp。 jstack用於生成java虛擬機當前時刻的線程快照。線程快照是...
繼續訪問
linux查看java堆棧
1、查看JAVA進程JVM參數 jinfo -flags pid(進程號) -XX:CICompilerCount=2 最大的並行編譯數 -XX:InitialHeapSize=16777216 JVM 的初始堆內存大小 -XX:MaxHeapSize=257949696 JVM 的最大堆內存大小 -XX:MaxNewSize=85983232 -XX:MinHeapDeltaBytes=196608 -XX:NewSize=5570560 -XX:OldSize=11206656 2、JVM 查看.
繼續訪問
Linux 如何查看一個進程的堆棧
有兩種方法：第一種：pstack 進程ID第二種，使用gdb 然後attach 進程ID，然後再使用命令 thread apply all bt 兩種方法都可以列出進程所有的線程的當前的調用棧。不過，使用gdb的方法，還可以查看某些信息，例如局部變數，指針等。不過，如果只看調用棧的話，pstack還是很方便的。
繼續訪問
JAVA獲取堆棧信息
1. 通過Throwable獲取 StackTraceElement[] stackTrace = new Throwable().getStackTrace(); 2. 通過Thread獲取 StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
繼續訪問
java 查看線程棧大小_基於 Java 線程棧的問題排查
除日誌外，還有沒有別的方式跟蹤線上服務問題呢？或者，跟蹤並排除日誌里無法發現的問題？方法當然是有的，就是通過現場快照定位並發現問題。我們所說的現場，主要指這兩方面：Java 線程棧。線程棧是Java線程工作的快照，可以獲得當前線程在做什麼；Java 內存堆。堆是JVM的內存快照，可以獲取內存分配相關信息。
10. 在新建虛擬機時出現問題
JConsole
JConsole 圖形用戶界面是一種符合 Java 管理擴展（JMX）規范的監視工具。JConsole 使用 Java 虛擬機 （Java VM） 的廣泛檢測來提供有關在 Java 平台上運行的應用程序的性能和資源消耗的信息。
使用方法 本地
使用jconsole命令：監視本地運行的所有 Java 應用程序，JConsole 可以連接到這些應用程序。
使用jconsole PID命令：監視指定PID的Java應用程序。
使用jsconsole hostName:portNum命令：hostName是運行應用程序的系統的名稱，portNum是您在啟動Java VM時啟用 JMX 代理時指定的埠號。
使用service:jmx::命令：使用 JMX 服務 URL 進行連接。
內容分析
將 JConsole 連接到應用程序後，JConsole 由六個選項卡組成。
概述：顯示有關 Java VM 和受監視值的概述信息。
內存：顯示有關內存使用的信息。
線程：顯示有關線程使用的信息。
類：顯示有關類載入的信息。
VM：顯示有關 Java VM 的信息。
MBeans：顯示有關 MBeans 的信息。
顯示有關 CPU 使用情況、內存使用情況、線程計數和在Java VM中載入的類的圖形監視信息。
提供執行GC的操作，可以隨時點擊按鈕進行垃圾回收
伊甸園空間（堆）：最初為大多數對象分配內存的池。
倖存者空間（堆）：包含在伊甸園空間垃圾回收中倖存下來的物體的池。
終身代（堆）：包含在倖存者空間中存在一段時間的對象的池。
永久生成（非堆）：包含虛擬機本身的所有反射數據的池，如類和方法對象。使用類數據共享的 Java VM，這一代分為只讀和讀寫區域。
代碼緩存（非堆）：HotSpotJava VM 還包括一個代碼緩存，其中包含用於編譯和存儲本機代碼的內存。
Java VM管理兩種類型的內存：堆內存和非堆內存，這兩種內存都是在 Java VM 啟動時創建的。
堆內存是Java VM為所有類實例和數組分配內存的運行時數據區域。堆的大小可能是固定的或可變的。垃圾回收器是一個自動內存管理系統，用於回收對象的堆內存。
非堆內存包括所有線程之間共享的方法區域和Java VM的內部處理或優化所需的內存。它存儲每類結構，如運行時常量池、欄位和方法數據，以及方法和構造函數的代碼。方法區域在邏輯上是堆的一部分，但是，根據實現，Java VM 可能不會對它進行垃圾回收或壓縮。與堆內存一樣，方法區域可能為固定大小或可變大小。方法區域的內存不需要連續。
內存池和內存管理器是Java VM內存系統的關鍵方面。
內存池表示Java VM管理的內存區域。Java VM至少有一個內存池，它可能會在執行期間創建或刪除內存池。內存池可以屬於堆內存或非堆內存。
內存管理器管理一個或多個內存池。垃圾回收器是一種內存管理器，負責回收不可到達的對象使用的內存。Java VM可能具有一個或多個內存管理器。它可以在執行期間添加或刪除內存管理器。內存池可以由多個內存管理器管理。
垃圾回收 （GC） 是Java VM釋放不再引用的對象佔用的內存的方式。通常認為具有活動引用為"活動"且未引用（或無法訪問）對象的對象為"已死"。垃圾回收是釋放死對象使用的內存的過程。GC 使用的演算法和參數對性能有顯著影響。
Java hotspot VM垃圾回收器使用代數 GC。生成 GC 利用大多數程序符合以下概括的觀察。
它們創建許多壽命較短的對象，例如迭代器和局部變數。
它們創建一些壽命很長的對象，例如高級持久對象。
提供有關線程使用的信息。
查找監視器死鎖線程：檢測對象監視器鎖上是否有任何線程死鎖。此操作返回死鎖線程指示的數組。
getThreadInfo：返回線程信息。這包括線程當前被阻止的名稱、堆棧跟蹤和監視器鎖（如果有）以及持有該鎖的線程以及線程爭用統計信息。
獲取ThreadCpu時間：返回給定線程消耗的 CPU 時間
顯示有關類載入的信息。
提供有關Java VM的信息。
以通用方式顯示有關在平台 MBean 伺服器注冊的所有 MBeans 的信息。MBeans 選項卡允許您訪問平台 MXBean 檢測的完整集，包括在其他選項卡中不可見的儀器。此外，您還可以使用 MBeans 選項卡監視和管理應用程序的 MBeans。
列出目標系統上已檢測的 Java 虛擬機 （JVM）。
監視 Java 虛擬機 （JVM） 統計信息。
對Java應用程序的資源和性能進行實時的命令行的監控，包括了對Heap size和垃圾回收狀況的監控。
命令格式
jstat [-option] [PID]
option參數
class：顯示有關類載入器行為的統計信息。
compiler：顯示有關Java HotSpot VM實時編譯器行為的統計信息。
gc：顯示有關垃圾回收堆行為的統計信息。
gccapacity：顯示有關幾代人容量及其相應空間的統計信息。
gccause：顯示有關垃圾回收統計信息（與 相同）的摘要，以及最後和當前（如果適用）垃圾回收事件的原因。-gcutil
gcnew：顯示新一代行為的統計信息。
gcnewcapacity：顯示有關新一代大小及其相應空間的統計信息。
gcold：顯示有關舊一代和元空間統計信息行為的統計信息。
gcoldcapacity：顯示有關舊一代大小的統計信息。
gcmetacapacity：顯示有關元空間大小的統計信息。
gcutil：顯示有關垃圾回收統計信息的摘要。
printcompilation：顯示 Java 熱點 VM 編譯方法統計信息。
1.jstat –class: 顯示載入class的數量，及所佔空間等信息。
2.jstat -compiler顯示VM實時編譯的數量等信息。
3.jstat -gc: 可以顯示gc的信息，查看gc的次數，及時間。
4.jstat -gccapacity:可以顯示，VM內存中三代（young,old,perm）對象的使用和佔用大小
5.jstat -gcutil:統計gc信息
6.jstat -gcnew:年輕代對象的信息。
7.jstat -gcnewcapacity: 年輕代對象的信息及其佔用量。
8.jstat -gcold：old代對象的信息。
9.jstat -gcoldcapacity: old代對象的信息及其佔用量。
10.jstat -gcpermcapacity: perm對象的信息及其佔用量。
11.jstat -printcompilation：當前VM執行的信息。
監視 Java 虛擬機 （JVM），並使遠程監視工具能夠連接到 JVM
命令格式
jstatd -[option]
option
-nr當找不到現有的RMI注冊表時，不嘗試使用jstatd進程創建一個內部的RMI注冊表。
-p port在指定的埠查找RMI注冊表。如果沒有找到，並且沒有指定-nr選項，則在該埠自行創建一個內部的RMI注冊表。
-n rminameRMI注冊表中綁定的RMI遠程對象的名稱。默認的名稱為JStatRemoteHost。如果多個jstatd伺服器在同一主機上運行，你可以通過指定該選項來讓每個伺服器導出的RMI對象具有唯一的名稱。不管如何，這樣做需要將唯一的伺服器名稱包含進監控客戶端的hostid和vmid字元串中。
-Joption將選項參數傳遞給被javac調用的java啟動程序。例如，-J-Xms48m設置啟動內存為48 MB。使用-J將選項參數傳遞給執行Java應用程序的底層虛擬機，這是一種常見慣例。
使用方法
1.在jdk的bin目錄下創建文件jstatd.all.policy
2.寫入下面的安全配置
grant codebase "file:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.191.b12-1.el7_6.x86_64/lib/tools.jar" {
permission java.security.AllPermission;
#此處寫絕對路徑，主要是防止路徑錯誤問題，排查問題，應該寫成相對路徑
3.啟動jstatd
./jstatd -J-Djava.security.policy=jstatd.all.policy -J-Djava.rmi.server.hostname=x.x.x.x &
4.使用jvisualvm工具遠程連接，進行監控
jvisualvm
VisualVM，能夠監控線程，內存情況，查看方法的CPU時間和內存中的對 象，已被GC的對象，反向查看分配的堆棧(如100個String對象分別由哪幾個對象分配出來的).
同時他還提供很多插件可以自己安裝，是一款不錯的監控分析工具。
故障排除工具 JInfo
可以用來查看正在運行的 java 應用程序的擴展參數，包括Java System屬性和JVM命令行參數；也可以動態的修改正在運行的 JVM 一些參數。當系統崩潰時，jinfo可以從core文件裡面知道崩潰的Java應用程序的配置信息
命令格式
參數說明
pid對應jvm的進程id
executable core產生core mp文件
[server-id@]remote server IP or hostname遠程的ip或者hostname，server-id標記服務的唯一性id
option
no option輸出全部的參數和系統屬性
-flag name輸出對應名稱的參數
-flag [+|-]name開啟或者關閉對應名稱的參數
-flag name=value設定對應名稱的參數
-flags輸出全部的參數
-sysprops輸出系統屬性
Javacore 概述
Javacore，也可以稱為「threadmp」或是「javamp」，它是 Java 提供的一種診斷特性，能夠提供一份可讀的當前運行的 JVM 中線程使用情況的快照。即在某個特定時刻，JVM 中有哪些線程在運行，每個線程執行到哪一個類，哪一個方法。應用程序如果出現不可恢復的錯誤或是內存泄露，就會自動觸發 Javacore 的生成。
使用方法
1.jinfo pid：輸出當前 jvm 進程的全部參數和系統屬性
2.jinfo -flag name pid：輸出對應名稱的參數使用該命令，可以查看指定的 jvm 參數的值。如：查看當前 jvm 進程是否開啟列印 GC 日誌。
3.jinfo -flag [+|-]name pid：開啟或者關閉對應名稱的參數
使用 jinfo 可以在不重啟虛擬機的情況下，可以動態的修改 jvm 的參數。尤其在線上的環境特別有用。
4.jinfo -flag name=value pid：修改指定參數的值。
5.jinfo -flags pid：輸出全部的參數
6.jinfo -sysprops pid：輸出當前 jvm 進行的全部的系統屬性
jhat
主要是用來分析java堆的命令，可以將堆中的對象以html的形式顯示出來，包括對象的數量，大小等等，並支持對象查詢語言。
1.使用jmap命令導出堆文件jmap -mp:live,file=a.log pid
也可以使用下面方式導出堆文件
1、使用jconsole選項通過HotSpotDiagnosticMXBean從運行時獲得堆轉儲（生成mp文件）、
2、虛擬機啟動時如果指定了-XX:+HeapDumpOnOutOfMemoryError選項, 則在拋出OutOfMemoryError時, 會自動執行堆轉儲。
3、使用hprof命令
2.使用jhat分析堆文件jhat -J-Xmx512M a1.log
3.查看分析的html頁面
http://ip:7000/jhat中的OQL（對象查詢語言）
如果需要根據某些條件來過濾或查詢堆的對象，這是可能的，可以在jhat的html頁面中執行OQL，來查詢符合條件的對象
基本語法：
select
[from [instanceof] ]
[where ]
解釋：
(1)class name是java類的完全限定名，如：java.lang.String,java.util.ArrayList, C是char數組,java.io.File是java.io.File[]
(2)類的完全限定名不足以唯一的辨識一個類，因為不同的ClassLoader載入的相同的類，它們在jvm中是不同類型的
(3)instanceof表示也查詢某一個類的子類，如果不明確instanceof，則只精確查詢class name指定的類
(4)from和where子句都是可選的
(5)java域表示：obj.field_name；java數組表示：array[index]
舉例：
（1）查詢長度大於100的字元串
select s from java.lang.String s where s.count > 100
（2）查詢長度大於256的數組
select a from [I a where a.length > 256
（3）顯示匹配某一正則表達式的字元串
select a.value.toString() from java.lang.String s where /java/(s.value.toString())
（4）顯示所有文件對象的文件路徑
select file.path.value.toString() from java.io.File file
（5）顯示所有ClassLoader的類名
select classof(cl).name from instanceof java.lang.ClassLoader cl
（6）通過引用查詢對象
select o from instanceof 0xd404d404 o
built-in對象 -- heap
(1)heap.findClass(class name) -- 找到類
select heap.findClass("java.lang.String").superclass
(2)heap.findObject(object id) -- 找到對象
select heap.findObject("0xd404d404")
(3)heap.classes -- 所有類的枚舉
select heap.classes
(4)heap.objects -- 所有對象的枚舉
select heap.objects("java.lang.String")
(5)heap.finalizables -- 等待垃圾收集的java對象的枚舉
(6)heap.livepaths -- 某一對象存活路徑
select heaplivepaths(s) from java.lang.String s
(7)heap.roots -- 堆根集的枚舉
辨識對象的函數
(1)classof(class name) -- 返回java對象的類對象
select classof(cl).name from instanceof java.lang.ClassLoader cl
(2)identical(object1,object2) -- 返回是否兩個對象是同一個實例
select identical(heap.findClass("java.lang.String").name, heap.findClass("java.lang.String").name)
(3)objectid(object) -- 返回對象的id
select objectid(s) from java.lang.String s
(4)reachables -- 返回可從對象可到達的對象
select reachables(p) from java.util.Properties p -- 查詢從Properties對象可到達的對象
select reachables(u, "java.net.URL.handler") from java.net.URL u -- 查詢從URL對象可到達的對象，但不包括從URL.handler可到達的對象
(5)referrers(object) -- 返回引用某一對象的對象
select referrers(s) from java.lang.String s where s.count > 100
(6)referees(object) -- 返回某一對象引用的對象
select referees(s) from java.lang.String s where s.count > 100
(7)refers(object1,object2) -- 返回是否第一個對象引用第二個對象
select refers(heap.findObject("0xd4d4d4d4"),heap.findObject("0xe4e4e4e4"))
(8)root(object) -- 返回是否對象是根集的成員
select root(heap.findObject("0xd4d4d4d4"))
(9)sizeof(object) -- 返回對象的大小
select sizeof(o) from [I o
(10)toHtml(object) -- 返回對象的html格式
select "+ toHtml(o) + "" from java.lang.Object o
(11)選擇多值
select {name:t.name?t.name.toString():"null",thread:t} from instanceof java.lang.Thread t
數組、迭代器等函數
(1)concat(enumeration1,enumeration2) -- 將數組或枚舉進行連接
select concat(referrers(p),referrers(p)) from java.util.Properties p
(2)contains(array, expression) -- 數組中元素是否滿足某表達式
select p from java.util.Properties where contains(referres(p), "classof(it).name == 'java.lang.Class'")
返回由java.lang.Class引用的java.util.Properties對象
built-in變數
it -- 當前的迭代元素
index -- 當前迭代元素的索引
array -- 被迭代的數組
(3)count(array, expression) -- 滿足某一條件的元素的數量
select count(heap.classes(), "/java.io./(it.name)")
(4)filter(array, expression) -- 過濾出滿足某一條件的元素
select filter(heap.classes(), "/java.io./(it.name)")
(5)length(array) -- 返回數組長度
select length(heap.classes())
(6)map(array,expression) -- 根據表達式對數組中的元素進行轉換映射
select map(heap.classes(),"index + '-->' + toHtml(it)")
(7)max(array,expression) -- 最大值, min(array,expression)
select max(heap.objects("java.lang.String"),"lhs.count>rhs.count")
built-in變數
lhs -- 左邊元素
rhs -- 右邊元素
(8)sort(array,expression) -- 排序
select sort(heap.objects('[C'),'sizeof(lhs)-sizeof(rhs)')
(9)sum(array,expression) -- 求和
select sum(heap.objects('[C'),'sizeof(it)')
(10)toArray(array) -- 返回數組
(11)unique(array) -- 唯一化數組
jmap
列印進程、核心文件或遠程調試伺服器的共享對象內存映射或堆內存詳細信息。
jmap [option]
(to connect to running process) 連接到正在運行的進程
jmap [option]
(to connect to a core file) 連接到核心文件
jmap [option] [server_id@]
(to connect to remote debug server) 連接到遠程調試服務
option
pid:目標進程的PID，進程編號，可以採用ps -ef | grep java查看java進程的PID;
executable:產生core mp的java可執行程序;
core:將被列印信息的core mp文件;
remote-hostname-or-IP:遠程debug服務的主機名或ip;
server-id:唯一id，假如一台主機上多個遠程debug服務;
使用方法
jmap -mp:[live,]format=b,file= PID：使用hprof二進制形式，輸出jvm的heap內容到文件
jmap -finalizerinfo PID：列印正等候回收的對象的信息
jmap -heap PID：列印heap的概要信息，GC使用的演算法，heap（堆）的配置及JVM堆內存的使用情況。
jmap -histo:live PID：列印每個class的實例數目,內存佔用,類全名信息。VM的內部類名字開頭會加上前綴」*」. 如果live子參數加上後,只統計活的對象數量.
jmap -permstat PID：列印classload和jvm heap長久層的信息. 包含每個classloader的名字、活潑性、地址、父classloader和載入的class數量。另外，內部String的數量和佔用內存數也會列印出來。
-F強迫.在pid沒有相應的時候使用-mp或者-histo參數。在這個模式下，live子參數無效。
-h | -help列印輔助信息
-J傳遞參數給jmap啟動的jvm.
jstack命令主要用於調試java程序運行過程中的線程堆棧信息，可以用於檢測死鎖，進程耗用cpu過高報警問題的排查。jstack命令會列印出所有的線程，包括用戶自己啟動的線程和jvm後台線程。
命令格式
jstack -[option] pid
option
-F強制mp線程堆棧信息. 用於進程hung住，jstack命令沒有響應的情況
-m同時列印java和本地(native)線程棧信息，m是mixed mode的簡寫
-l列印鎖的額外信
公眾號「Java精選」所發表內容註明來源的，版權歸原出處所有（無法查證版權的或者未註明出處的均來自網路，系轉載，轉載的目的在於傳遞更多信息，版權屬於原作者。如有侵權，請聯系，筆者會第一時間刪除處理！
最近有很多人問，有沒有讀者交流群！加入方式很簡單，公眾號Java精選，回復「加群」，即可入群！
（微信小程序）：3000+道面試題，包含Java基礎、並發、JVM、線程、MQ系列、Redis、Spring系列、Elasticsearch、Docker、K8s、Flink、Spark、架構設計等，在線隨時刷題！
------ 特別推薦 ------
特別推薦：專注分享最前沿的技術與資訊，為彎道超車做好准備及各種開源項目與高效率軟體的公眾號，「大咖筆記」，專注挖掘好東西，非常值得大家關注。點擊下方公眾號卡片關注。
文章有幫助的話，在看，轉發吧！