JVM常用的命令

jps ：基礎工具

查看JAVA進程PID。

jps 命令用來查看所有 Java 進程，每一行就是一個 Java 進程信息。

jps 僅查找當前用戶的 Java 進程，而不是當前系統中的所有進程，要顯示其他用戶的還只能用 ps 命令。

jps 常用參數

jps -l 如果是以 class 方式運行，會顯示進程的主類 main.class 的全名，如果是以 jar 包方式運行的，就會輸出 jar 包的完整路徑名

第一列的數字就是進程的 pid

jps -v 輸出傳遞給 JVM 的參數，v 表示虛擬機，jps -vl 比較常見的組合；
jps -V 大寫 v，表示通過文件傳遞給 JVM 的參數

Copy# michael @ Michael-MBP in ~ [16:37:59]
$ jps -v |grep Mybatis
8005 MybatisDemoApplication -agentlib:jdwp=transport=dt_socket,address=127.0.0.1:53364,suspend=y,server=n -XX:TieredStopAtLevel=1 -Xverify:none -Dspring.output.ansi.enabled=always -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=53363 -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false -Djava.rmi.server.hostname=127.0.0.1 -Dspring.liveBeansView.mbeanDomain -Dspring.application.admin.enabled=true -javaagent:/Users/michael/Library/Caches/IntelliJIdea2018.2/captureAgent/debugger-agent.jar=file:/private/var/folders/m1/ydypchs901lffc5sms07mrp40000gn/T/capture.props -Dfile.encoding=UTF-8

jps -m 輸出傳遞給 main.class 方法的參數，實用的一個命令，jps -ml 比較實用的組合，會顯示包名/類名/參數
jps -q 只輸出進程的 pid

jps 是比較常用的 Java 命令。使用 jps 可以查看當前有哪些 Java 進程處於運行狀態。如果運行了一個 web 應用（使用tomcat、jboss、jetty等啓動）的時候，就可以使用 jps 查看啓動情況。

有的時候我想知道這個應用的日誌會輸出到哪裏，或者啓動的時候使用了哪些javaagent，那麼我可以使用 jps -v 查看進程的jvm參數情況。

jinfo：命令可以用來查看 Java 進程運行的 JVM 參數、

參考原文：https://blog.csdn.net/yx0628/article/details/80958488

jinfo -flag initilHeapSize ${PID} 查看某個JAVA進程中，JVM的參數值是什麼。

jinfo -flag ${PID} 如果不加JVM參數的話，默認查看JVM中所有被修改過的值。

[root@admin ~]# jinfo --help
Usage:
    jinfo [option] <pid>
        (to connect to running process)
    jinfo [option] <executable <core>
        (to connect to a core file)
    jinfo [option] [server_id@]<remote server IP or hostname>
        (to connect to remote debug server)

where <option> is one of:
    -flag <name>         to print the value of the named VM flag
    -flag [+|-]<name>    to enable or disable the named VM flag
    -flag <name>=<value> to set the named VM flag to the given value
    -flags               to print VM flags
    -sysprops            to print Java system properties
    <no option>          to print both of the above
    -h | -help           to print this help message

我們先用 jps 命令查到 PID ，然後可以通過 jinfo 來查看對應進程的參數信息：

[root@admin ~]# jps
43520 Test
35900 Jps

查看 JVM 參數：

[root@admin ~]# jinfo -flags 43520
Attaching to process ID 43520, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 24.45-b08

-Dfile.encoding=GBK

查看系統參數：

[root@admin ~]# jinfo -sysflags 43520

虛擬機的參數可以通過這個命令查看：

java -XX:+PrintFlagsFinal -version | grep manageable

除了通過啓動腳本可以設置參數，PrintGC 默認是打開的，因此我們只需要打開 PrintGCDetails 參數。

jinfo -flag +PrintGC 43520
jinfo -flag +PrintGCDetails 43520

關閉 GC 日誌的話同理：

jinfo -flag -PrintGC 43520
jinfo -flag -PrintGCDetails 43520

查看是否開啓 GC 日誌的打印：

jinfo -flag PrintGC 43520
jinfo -flag PrintGCDetails 43520

[root@admin ~]# jinfo -flag PrintGC 43520
-XX:-PrintGC

[root@admin ~]# jinfo -flag PrintGCDetails 43520
-XX:-PrintGCDetails

常用 JVM 參數：

-Xms：初始堆大小，默認爲物理內存的1/64(<1GB)；默認(MinHeapFreeRatio參數可以調整)空餘堆內存小於40%時，JVM就會增大堆直到-Xmx的最大限制
-Xmx：最大堆大小，默認(MaxHeapFreeRatio參數可以調整)空餘堆內存大於70%時，JVM會減少堆直到 -Xms的最小限制
-Xmn：新生代的內存空間大小，注意：此處的大小是（eden+ 2 survivor space)。與jmap -heap中顯示的New gen是不同的。整個堆大小=新生代大小 + 老生代大小 + 永久代大小。在保證堆大小不變的情況下，增大新生代後,將會減小老生代大小。此值對系統性能影響較大,Sun官方推薦配置爲整個堆的3/8。
-XX:SurvivorRatio：新生代中Eden區域與Survivor區域的容量比值，默認值爲8。兩個Survivor區與一個Eden區的比值爲2:8,一個Survivor區佔整個年輕代的1/10。
-Xss：每個線程的堆棧大小。JDK5.0以後每個線程堆棧大小爲1M,以前每個線程堆棧大小爲256K。應根據應用的線程所需內存大小進行適當調整。在相同物理內存下,減小這個值能生成更多的線程。但是操作系統對一個進程內的線程數還是有限制的，不能無限生成，經驗值在3000~5000左右。一般小的應用， 如果棧不是很深， 應該是128k夠用的，大的應用建議使用256k。這個選項對性能影響比較大，需要嚴格的測試。和threadstacksize選項解釋很類似,官方文檔似乎沒有解釋,在論壇中有這樣一句話:"-Xss is translated in a VM flag named ThreadStackSize”一般設置這個值就可以了。
-XX:PermSize：設置永久代(perm gen)初始值。默認值爲物理內存的1/64。
-XX:MaxPermSize：設置持久代最大值。物理內存的1/4。

jstat：主要是對java應用程序的資源和性能進行實時的命令行監控，包括了對heap size和垃圾回收狀況的監控

原文參考：https://blog.csdn.net/cockroach02/article/details/82670500

查看JVM中相關性能的信息。

jstat（Java Virtual Machine Statistics Monitoring Tool）是從JDK1.5自帶的一個輕量級小工具。它位於java/bin目錄下，主要利用JVM內建的指令對Java虛擬機的資源和性能進行實時的監控。

類裝載信息：jstat -class ${PID}

舉例：jstat -class ${PID} ${幾秒內打印一次} ${打印10次} = jstat -class ${PID} 1000 10。打印出過去10秒類加載的數據。

GC相關的情況：jstat -gc ${PID}

舉例：jstat -gc ${PID} ${幾秒內打印一次} ${打印10次} = jstat -gc ${PID} 1000 10。打印出過去10秒GC的數據。

參數說明：

C:\Users\Administrator>jstat -help
Usage: jstat -help|-options
       jstat -<option> [-t] [-h<lines>] <vmid> [<interval> [<count>]]

Definitions:
  <option>      An option reported by the -options option
  <vmid>        Virtual Machine Identifier. A vmid takes the following form:
                     <lvmid>[@<hostname>[:<port>]]
                Where <lvmid> is the local vm identifier for the target
                Java virtual machine, typically a process id; <hostname> is
                the name of the host running the target Java virtual machine;
                and <port> is the port number for the rmiregistry on the
                target host. See the jvmstat documentation for a more complete
                description of the Virtual Machine Identifier.
  <lines>       Number of samples between header lines.
  <interval>    Sampling interval. The following forms are allowed:
                    <n>["ms"|"s"]
                Where <n> is an integer and the suffix specifies the units as
                milliseconds("ms") or seconds("s"). The default units are "ms".
  <count>       Number of samples to take before terminating.
  -J<flag>      Pass <flag> directly to the runtime system.

由以上可知，jstat的命令的格式如下：

jstat -<option> [-t] [-h<lines>] <vmid> [<interval> [<count>]]

我們可以通過jstat -options查看可以支持的具體參數

C:\Users\Administrator>jstat -options
-class
-compiler
-gc
-gccapacity
-gccause
-gcmetacapacity
-gcnew
-gcnewcapacity
-gcold
-gcoldcapacity
-gcutil
-printcompilation

Option參數說明：

參數	說明
-class	類加載的行爲統計 Displays statistics about the behavior of the class loader.
-compiler	HotSpt JIT編譯器行爲統計 Displays statistics about the behavior of the Java HotSpot VM Just-in-Time compiler.
-gc	垃圾回收堆的行爲統計。Displays statistics about the behavior of the garbage collected heap.
-gccapacity	各個垃圾回收代容量(young,old,meta)和他們相應的空間統計。isplays statistics about the capacities of the generations and their corresponding spaces.
-gccause	垃圾收集統計概述（同-gcutil）,附加最近兩次垃圾回收事件的原因。Displays a summary about garbage collection statistics (same as -gcutil), with the cause of the last and current (when applicable) garbage collection events.
-gcmetacapacity	統計元空間使用情況 Displays statistics about the sizes of the metaspace.
-gcnew	顯示新生代統計信息 Displays statistics of the behavior of the new generation.
-gcnewcapacity	統計新生代及內存使用情況 Displays statistics about the sizes of the new generations and its corresponding spaces.
-gcold	統計老年代和元空間使用情況 Displays statistics about the behavior of the old generation and metaspace statistics.
-gcoldcapacity	統計老年代內存使用情況 Displays statistics about the sizes of the old generation.
-gcutil	顯示各個各代內存使用百分比 Displays a summary about garbage collection statistics.
-printcompilation	Hotspot方法編譯統計情況 Displays Java HotSpot VM compilation method statistics.

使用示例：

jstat -class ：類加載的行爲統計

C:\Users\Administrator>jstat -class 2284
Loaded  Bytes  Unloaded  Bytes     Time
 30116 75021.8       26    51.4      86.72

Loaded ：加載class的數量
Bytes ：加載class的大小（單位KB）
Unloaded ：卸載class的數量
Bytes：卸載class的大小（單位KB）
Time ：加載和卸載class所耗費的時間

jstat -compiler ：HotSpt JIT編譯器行爲統計

C:\Users\Administrator>jstat -compiler 2284
Compiled Failed Invalid   Time   FailedType FailedMethod
   21247      8       0   189.38          1 com/fr/third/alibaba/druid/pool/DruidDataSource shrink

Compiled ：編譯成功數
Failed ：編譯失敗數
Invalid ：無效數量
FailedType ：最後一次編譯失效類型
FailedMethod ：最後一次編譯失效的方法

jstat -gc：垃圾回收堆的行爲統計

C:\Users\Administrator>jstat -gc 2284
 S0C    S1C    S0U    S1U      EC       EU        OC         OU       MC     MU    CCSC   CCSU   YGC     YGCT    FGC    FGCT     GCT
104832.0 104832.0  0.0    0.0   838912.0 600103.2 1048576.0   565828.4  238672.0 232272.3 22392.0 21028.5     59    4.898  11      6.323   11.221

S0C ：第一個倖存區的總容量（KB）
S1C ：第二個倖存區的總容量（KB）
S0U ：第一個倖存區已使用的容量（KB）
S1U ：第二個倖存區已使用的容量（KB）
EC ：伊甸區的總容量（KB）
EU ：伊甸區已使用容量（KB）
OC ：老年區的總容量（KB）
MC ：元空間的總容量（KB）
MU ：元空間已使用容量（KB）
CCSC ：壓縮類空間總容量（KB）
CCSU ：壓縮類空間已使用總容量（KB）
YGC ：新生代GC次數
YGCT ：新生代GC總耗費時間
FGC ：老年代GC次數
FGCT ：老年代GC總耗費時間
GCT ： GC總耗費時間

jstat -gccapacity ：各個回收區內存情況

C:\Users\Administrator>jstat -gccapacity 2284
 NGCMN    NGCMX     NGC     S0C   S1C       EC      OGCMN      OGCMX       OGC         OC       MCMN     MCMX      MC     CCSMN    CCSMX     CCSC    YGC    FGC
1048576.0 1048576.0 1048576.0 104832.0 104832.0 838912.0  1048576.0  3145728.0  1048576.0  1048576.0      0.0 1265664.0 238672.0      0.0 1048576.0  22392.0
59    11

NGCMN ：新生代佔用的最小空間大小（KB）
NGCMX ：新生代佔用的最大空間大小（KB）
NGC ：當前新生代空間大小（KB）
S0C ：第一倖存區當前空間大小（KB）
S1C ：第二倖存區當前空間大小（KB）
EC ：伊甸區當前空間大小（KB）
OGCMN ：老年區最小空間大小（KB）
OGCMX ：老年區最大空間大小（KB）
OGC ：老年區當前空間大小（KB）
MCMN ：元空間最小空間大小（KB）
MCMX ：元空間最大空間大小（KB）
MC ：元空間當前空間大小（KB）
CCSMN ：壓縮類空間最小大小（KB）
CCSMX ：壓縮類最大空間大小（KB）
CCSC ：壓縮類當前空間大小（KB）
YGC ：新生代GC次數
FGC ：老年代GC次數

jstat -gccause ：垃圾收集統計概述

C:\Users\Administrator>jstat -gccause 2284
  S0     S1     E      O      M     CCS    YGC     YGCT    FGC    FGCT     GCT    LGCC                 GCC
  0.00   0.00  91.90  53.96  97.32  93.91     59    4.898    11    6.323   11.221 System.gc()          No GC

S0 ：第一倖存區已使用空間百分比.
S1 ：第二倖存區已使用空間百分比
E ：伊甸區已使用空間百分比
O ：老年區已使用空間百分比
M ：元空間使用百分比
CCS ：壓縮類空間使用百分比
YGC ：新生代GC次數
FGC ：老年代GC次數
LGCC ：最近一次GC原因
GCC ：當前GC原因

6 . gc -gcmetacapacity ：元空間使用情況

C:\Users\Administrator>jstat -gcmetacapacity 2284
   MCMN       MCMX        MC       CCSMN      CCSMX       CCSC     YGC   FGC    FGCT     GCT
       0.0  1265664.0   238672.0        0.0  1048576.0    22392.0    59    11    6.323   11.221

MCMN ：元空間最小空間大小（KB）
MCMX ：元空間最大空間大小（KB）
MC ：元空間當前空間大小（KB）
CCSMN ：壓縮類空間最小空間大小（KB）
CCSMX ：壓縮類空間最大空間大小（KB）
CCSC ：壓縮類空間當前空間大小（KB）
YGC ：新生代GC次數
FGC ：老年代GC次數
FGCT：老年代GC耗費時間
GCT ： GC總耗費時間

7 . jstat -gcnew ：顯示新生代統計信息

C:\Users\Administrator>jstat -gcnew 2284
 S0C    S1C    S0U    S1U   TT MTT  DSS      EC       EU     YGC     YGCT
104832.0 104832.0 46710.2    0.0  6   6 52416.0 838912.0  22526.9     60    4.972

S0C ：第一倖存區總空間大小（KB）
S1C ：第二倖存區總空間大小（KB）
S0U ：第一倖存區已使用空間大小（KB）
S1U ：第二倖存區已使用空間大小（KB）
TT ：提升閾值(提升閾值)
MTT ：最大閾值
DSS ： survivor區域大小 (KB)
EC ：伊甸區總空間大小（KB）
EU ：伊甸區已使用空間大小（KB）

8 . jstat -gcnewcapacity ：統計新生代及內存使用情況

C:\Users\Administrator>jstat -gcnewcapacity 2284
  NGCMN      NGCMX       NGC      S0CMX     S0C     S1CMX     S1C       ECMX        EC      YGC   FGC
 1048576.0  1048576.0  1048576.0 104832.0 104832.0 104832.0 104832.0   838912.0   838912.0    60    11

NGCMN ：新生代最小空間大小（KB）
NGCMX ：新生代最大空間大小（KB）
NGC ：當前新生代空間大小（KB）
S0CMX ：第一倖存區最大空間大小（KB）
S0C ：第一倖存區當前空間大小（KB）
S1CMX ：第二倖存區最大空間大小（KB）
S1C ：第二倖存區當前空間大小（KB）
ECMX ：伊甸區最大空間大小（KB）
EC ：伊甸區當前空間大小（KB）
YGC ：新生代GC次數
FGC ：老年代GC次數

9 . jstat -gcold ：統計老年代和元空間使用情況

C:\Users\Administrator>jstat -gcold 2284
   MC       MU      CCSC     CCSU       OC          OU       YGC    FGC    FGCT     GCT
251088.0 244521.5  23544.0  22058.7   1048576.0    565828.4     60    11    6.323   11.295

MC ：元空間總大小（KB）
MU ：元空間已使用大小（KB）
CCSC ：壓縮類空間總大小（KB）
CCSU ：壓縮類空間已使用大小（KB）
OC ：老年區空間總大小（KB）
OU ：老年區已使用大小（KB）
YGC ：新生代GC次數
FGC ：老年代GC次數
FGCT ：老年代GC總耗時
GCT ： GC總耗時

10 . jstat -gcoldcapacity ：統計老年代內存使用情況

C:\Users\Administrator>jstat -gcoldcapacity 2284
   OGCMN       OGCMX        OGC         OC       YGC   FGC    FGCT     GCT
  1048576.0   3145728.0   1048576.0   1048576.0    60    11    6.323   11.295

OGCMN ：老年區佔用最小空間（KB）
OGCMX ：老年區佔用最大空間（KB）
OGC ：當前老年區空間（KB）
OC ：當前老年區空間（KB）
YGC ：新生代GC次數
FGC ：老年代GC次數
FGCT ：老年代GC總耗時
GCT ： GC總耗時

11 . jstat -gcutil ：垃圾回收統計

C:\Users\Administrator>jstat -gcutil 2284
  S0     S1     E      O      M     CCS    YGC     YGCT    FGC    FGCT     GCT
 44.56   0.00   9.85  53.96  97.38  93.69     60    4.972    11    6.323   11.295

S0 ：第一倖存區已使用空間百分比.
S1 ：第二倖存區已使用空間百分比
E ：伊甸區已使用空間百分比
O ：老年區已使用空間百分比
M ：元空間使用百分比
CCS ：壓縮類空間使用百分比
YGC ：新生代GC次數
FGC ：老年代GC次數
GCT ：GC總耗時

12 . jstat -printcompilation ： Hotspot方法編譯統計情況

C:\Users\Administrator>jstat -printcompilation 2284
Compiled  Size  Type Method
   21538    150    1 java/util/Collections reverse

Compiled ：已編譯方法次數
Size ：最近一次方法編譯大小
Type ：最近一次編譯方法類型
Method ：最近一次編譯方法

參考：

jstat：https://docs.oracle.com/javase/8/docs/technotes/tools/unix/jstat.html
jstat命令使用：https://www.cnblogs.com/lizhonghua34/p/7307139.html
JVM調優命令-jstat：https://www.cnblogs.com/myna/p/7567769.html

jstack：查看某個Java進程內的線程堆棧信息

參考原文：https://www.jianshu.com/p/8d5782bc596e

查看JAVA進程當中，線程內容。

jstack用法

/opt/java8/bin/jstack

Usage:
    jstack [-l] <pid>
        (to connect to running process) 連接活動線程
    jstack -F [-m] [-l] <pid>
        (to connect to a hung process) 連接阻塞線程
    jstack [-m] [-l] <executable> <core>
        (to connect to a core file) 連接dump的文件
    jstack [-m] [-l] [server_id@]<remote server IP or hostname>
        (to connect to a remote debug server) 連接遠程服務器

Options:
    -F  to force a thread dump. Use when jstack <pid> does not respond (process is hung)
    -m  to print both java and native frames (mixed mode)
    -l  long listing. Prints additional information about locks
    -h or -help to print this help message

jstack查看輸出

/opt/java8/bin/jstack -l 28367

2019-06-25 15:04:46
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.77-b03 mixed mode):

"Attach Listener" #453 daemon prio=9 os_prio=0 tid=0x00007f9f94001000 nid=0xf30 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"grpc-default-executor-263" #452 daemon prio=5 os_prio=0 tid=0x00007f9f4c01f800 nid=0x9aa waiting on condition [0x00007f9f398bd000]
   java.lang.Thread.State: TIMED_WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000007400243f0> (a java.util.concurrent.SynchronousQueue$TransferStack)
        at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:215)
        at java.util.concurrent.SynchronousQueue$TransferStack.awaitFulfill(SynchronousQueue.java:460)
        at java.util.concurrent.SynchronousQueue$TransferStack.transfer(SynchronousQueue.java:362)
        at java.util.concurrent.SynchronousQueue.poll(SynchronousQueue.java:941)
        at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1066)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1127)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
        at java.lang.Thread.run(Thread.java:745)

   Locked ownable synchronizers:
        - None

"http-bio-8080-exec-10" #235 daemon prio=5 os_prio=0 tid=0x0000000001bcc800 nid=0x3c13 waiting on condition [0x00007f9f384a9000]
   java.lang.Thread.State: WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x0000000743d26638> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2039)
        at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:442)
        at org.apache.tomcat.util.threads.TaskQueue.take(TaskQueue.java:104)
        at org.apache.tomcat.util.threads.TaskQueue.take(TaskQueue.java:32)
        at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1067)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1127)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
        at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
        at java.lang.Thread.run(Thread.java:745)

   Locked ownable synchronizers:
        - None

jstack統計線程數

/opt/java8/bin/jstack -l 28367 | grep 'java.lang.Thread.State' | wc -l

jstack檢測死鎖

死鎖代碼

public class DeathLock {

    private static Lock lock1 = new ReentrantLock();
    private static Lock lock2 = new ReentrantLock();

    public static void deathLock() {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                try {
                    lock1.lock();
                    TimeUnit.SECONDS.sleep(1);
                    lock2.lock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                try {
                    lock2.lock();
                    TimeUnit.SECONDS.sleep(1);
                    lock1.lock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        t1.setName("thread1");
        t2.setName("thread2");
        t1.start();
        t2.start();
    }

    public static void main(String[] args) {
        deathLock();
    }
}

死鎖日誌

"mythread2" #12 prio=5 os_prio=0 tid=0x0000000058ef7800 nid=0x1ab4 waiting on condition [0x0000000059f8f000]
   java.lang.Thread.State: WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000000d602d610> (a java.util.concurrent.lock
s.ReentrantLock$NonfairSync)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInt
errupt(AbstractQueuedSynchronizer.java:836)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(A
bstractQueuedSynchronizer.java:870)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Abstrac
tQueuedSynchronizer.java:1199)
        at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLo
ck.java:209)
        at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)

        at DeathLock$2.run(DeathLock.java:34)

   Locked ownable synchronizers:
        - <0x00000000d602d640> (a java.util.concurrent.locks.ReentrantLock$Nonfa
irSync)

"mythread1" #11 prio=5 os_prio=0 tid=0x0000000058ef7000 nid=0x3e68 waiting on condition [0x000000005947f000]
   java.lang.Thread.State: WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000000d602d640> (a java.util.concurrent.lock
s.ReentrantLock$NonfairSync)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInt
errupt(AbstractQueuedSynchronizer.java:836)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(A
bstractQueuedSynchronizer.java:870)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Abstrac
tQueuedSynchronizer.java:1199)
        at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLo
ck.java:209)
        at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)

        at DeathLock$1.run(DeathLock.java:22)

   Locked ownable synchronizers:
        - <0x00000000d602d610> (a java.util.concurrent.locks.ReentrantLock$Nonfa
irSync)


Found one Java-level deadlock:
=============================
"mythread2":
  waiting for ownable synchronizer 0x00000000d602d610, (a java.util.concurrent.l
ocks.ReentrantLock$NonfairSync),
  which is held by "mythread1"
"mythread1":
  waiting for ownable synchronizer 0x00000000d602d640, (a java.util.concurrent.l
ocks.ReentrantLock$NonfairSync),
  which is held by "mythread2"

Java stack information for the threads listed above:
===================================================
"mythread2":
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000000d602d610> (a java.util.concurrent.lock
s.ReentrantLock$NonfairSync)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInt
errupt(AbstractQueuedSynchronizer.java:836)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(A
bstractQueuedSynchronizer.java:870)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Abstrac
tQueuedSynchronizer.java:1199)
        at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLo
ck.java:209)
        at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)

        at DeathLock$2.run(DeathLock.java:34)
"mythread1":
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000000d602d640> (a java.util.concurrent.lock
s.ReentrantLock$NonfairSync)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInt
errupt(AbstractQueuedSynchronizer.java:836)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(A
bstractQueuedSynchronizer.java:870)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Abstrac
tQueuedSynchronizer.java:1199)
        at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLo
ck.java:209)
        at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)

        at DeathLock$1.run(DeathLock.java:22)

Found 1 deadlock.

jstack檢測cpu高

步驟一：查看cpu佔用高進程

top

Mem:  16333644k total,  9472968k used,  6860676k free,   165616k buffers
Swap:        0k total,        0k used,        0k free,  6665292k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND     
17850 root      20   0 7588m 112m  11m S 100.7  0.7  47:53.80 java       
 1552 root      20   0  121m  13m 8524 S  0.7  0.1  14:37.75 AliYunDun   
 3581 root      20   0 9750m 2.0g  13m S  0.7 12.9 298:30.20 java        
    1 root      20   0 19360 1612 1308 S  0.0  0.0   0:00.81 init        
    2 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kthreadd    
    3 root      RT   0     0    0    0 S  0.0  0.0   0:00.14 migration/0

步驟二：查看cpu佔用高線程

top -H -p 17850

top - 17:43:15 up 5 days,  7:31,  1 user,  load average: 0.99, 0.97, 0.91
Tasks:  32 total,   1 running,  31 sleeping,   0 stopped,   0 zombie
Cpu(s):  3.7%us,  8.9%sy,  0.0%ni, 87.4%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Mem:  16333644k total,  9592504k used,  6741140k free,   165700k buffers
Swap:        0k total,        0k used,        0k free,  6781620k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND
17880 root      20   0 7588m 112m  11m R 99.9  0.7  50:47.43 java
17856 root      20   0 7588m 112m  11m S  0.3  0.7   0:02.08 java
17850 root      20   0 7588m 112m  11m S  0.0  0.7   0:00.00 java
17851 root      20   0 7588m 112m  11m S  0.0  0.7   0:00.23 java
17852 root      20   0 7588m 112m  11m S  0.0  0.7   0:02.09 java
17853 root      20   0 7588m 112m  11m S  0.0  0.7   0:02.12 java
17854 root      20   0 7588m 112m  11m S  0.0  0.7   0:02.07 java

步驟三：轉換線程ID

printf "%x\n" 17880          
45d8

步驟四：定位cpu佔用線程

jstack 17850|grep 45d8 -A 30
"pool-1-thread-11" #20 prio=5 os_prio=0 tid=0x00007fc860352800 nid=0x45d8 runnable [0x00007fc8417d2000]
   java.lang.Thread.State: RUNNABLE
        at java.io.FileOutputStream.writeBytes(Native Method)
        at java.io.FileOutputStream.write(FileOutputStream.java:326)
        at java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)
        at java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)
        - locked <0x00000006c6c2e708> (a java.io.BufferedOutputStream)
        at java.io.PrintStream.write(PrintStream.java:482)
        - locked <0x00000006c6c10178> (a java.io.PrintStream)
        at sun.nio.cs.StreamEncoder.writeBytes(StreamEncoder.java:221)
        at sun.nio.cs.StreamEncoder.implFlushBuffer(StreamEncoder.java:291)
        at sun.nio.cs.StreamEncoder.flushBuffer(StreamEncoder.java:104)
        - locked <0x00000006c6c26620> (a java.io.OutputStreamWriter)
        at java.io.OutputStreamWriter.flushBuffer(OutputStreamWriter.java:185)
        at java.io.PrintStream.write(PrintStream.java:527)
        - eliminated <0x00000006c6c10178> (a java.io.PrintStream)
        at java.io.PrintStream.print(PrintStream.java:597)
        at java.io.PrintStream.println(PrintStream.java:736)
        - locked <0x00000006c6c10178> (a java.io.PrintStream)
        at com.demo.guava.HardTask.call(HardTask.java:18)
        at com.demo.guava.HardTask.call(HardTask.java:9)
        at java.util.concurrent.FutureTask.run(FutureTask.java:266)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
        at java.lang.Thread.run(Thread.java:745)

"pool-1-thread-10" #19 prio=5 os_prio=0 tid=0x00007fc860345000 nid=0x45d7 waiting on condition [0x00007fc8418d3000]
   java.lang.Thread.State: WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000006c6c14178> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)

Jmap

原文參考：https://www.jianshu.com/p/c52ffaca40a5

jmap是JDK自帶的工具軟件，主要用於打印指定Java進程(或核心文件、遠程調試服務器)的共享對象內存映射或堆內存細節。可以使用jmap生成Heap Dump。在Java命令Java Dump和Java命令:Jstack中分別有關於Java Dump以及線程 Dump的介紹。這篇文章主要介紹Java的堆Dump以及jmap命令

什麼是堆Dump

基礎知識

Java虛擬機的內存組成以及堆內存介紹
 Java GC工作原理

常見內存錯誤：

outOfMemoryError 年老代內存不足。
outOfMemoryError:PermGen Space 永久代內存不足。
outOfMemoryError:GC overhead limit exceed 垃圾回收時間佔用系統運行時間的98%或以上。

jmap 用法摘要

Usage:
    jmap [option] <pid>
        (to connect to running process)
    jmap [option] <executable <core>
        (to connect to a core file)
    jmap [option] [server_id@]<remote server IP or hostname>
        (to connect to remote debug server)

where <option> is one of:
    <none>               to print same info as Solaris pmap
    -heap                to print java heap summary
    -histo[:live]        to print histogram of java object heap; if the "live"
                         suboption is specified, only count live objects
    -permstat            to print permanent generation statistics
    -finalizerinfo       to print information on objects awaiting finalization
    -dump:<dump-options> to dump java heap in hprof binary format
                         dump-options:
                           live         dump only live objects; if not specified,
                                        all objects in the heap are dumped.
                           format=b     binary format
                           file=<file>  dump heap to <file>
                         Example: jmap -dump:live,format=b,file=heap.bin <pid>
    -F                   force. Use with -dump:<dump-options> <pid> or -histo
                         to force a heap dump or histogram when <pid> does not
                         respond. The "live" suboption is not supported
                         in this mode.
    -h | -help           to print this help message
    -J<flag>             to pass <flag> directly to the runtime system

指定進程號(pid)的進程 jmap [ option ]
指定核心文件 jmap [ option ]
指定遠程調試服務器 jmap [ option ] [server-id@]

參數：

option 選項參數是互斥的(不可同時使用)。想要使用選項參數，直接跟在命令名稱後即可。
pid 需要打印配置信息的進程ID。該進程必須是一個Java進程。想要獲取運行的Java進程列表，你可以使用jps。
executable 產生核心dump的Java可執行文件。
core 需要打印配置信息的核心文件。
remote-hostname-or-IP 遠程調試服務器的(請查看jsadebugd)主機名或IP地址。
server-id 可選的唯一id，如果相同的遠程主機上運行了多臺調試服務器，用此選項參數標識服務器。

選項:

如果使用不帶選項參數的jmap打印共享對象映射，將會打印目標虛擬機中加載的每個共享對象的起始地址、映射大小以及共享對象文件的路徑全稱。這與Solaris的pmap工具比較相似。
-dump:[live,]format=b,file= 以hprof二進制格式轉儲Java堆到指定filename的文件中。live子選項是可選的。如果指定了live子選項，堆中只有活動的對象會被轉儲。想要瀏覽heap dump，你可以使用jhat(Java堆分析工具)讀取生成的文件。
-finalizerinfo 打印等待終結的對象信息。
-heap 打印一個堆的摘要信息，包括使用的GC算法、堆配置信息和generation wise heap usage。
-histo[:live] 打印堆的柱狀圖。其中包括每個Java類、對象數量、內存大小(單位：字節)、完全限定的類名。打印的虛擬機內部的類名稱將會帶有一個’*’前綴。如果指定了live子選項，則只計算活動的對象。
-permstat 打印Java堆內存的永久保存區域的類加載器的智能統計信息。對於每個類加載器而言，它的名稱、活躍度、地址、父類加載器、它所加載的類的數量和大小都會被打印。此外，包含的字符串數量和大小也會被打印。
-F 強制模式。如果指定的pid沒有響應，請使用jmap -dump或jmap -histo選項。此模式下，不支持live子選項。
-h 打印幫助信息。
-help 打印幫助信息。
-J 指定傳遞給運行jmap的JVM的參數。

示例：

查看java 堆（heap）使用情況,執行命令： jmap -heap 31846

Attaching to process ID 31846, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 24.71-b01

using thread-local object allocation.
Parallel GC with 4 thread(s)//GC 方式

Heap Configuration: //堆內存初始化配置
   MinHeapFreeRatio = 0 //對應jvm啓動參數-XX:MinHeapFreeRatio設置JVM堆最小空閒比率(default 40)
   MaxHeapFreeRatio = 100 //對應jvm啓動參數 -XX:MaxHeapFreeRatio設置JVM堆最大空閒比率(default 70)
   MaxHeapSize      = 2082471936 (1986.0MB) //對應jvm啓動參數-XX:MaxHeapSize=設置JVM堆的最大大小
   NewSize          = 1310720 (1.25MB)//對應jvm啓動參數-XX:NewSize=設置JVM堆的‘新生代’的默認大小
   MaxNewSize       = 17592186044415 MB//對應jvm啓動參數-XX:MaxNewSize=設置JVM堆的‘新生代’的最大大小
   OldSize          = 5439488 (5.1875MB)//對應jvm啓動參數-XX:OldSize=<value>:設置JVM堆的‘老生代’的大小
   NewRatio         = 2 //對應jvm啓動參數-XX:NewRatio=:‘新生代’和‘老生代’的大小比率
   SurvivorRatio    = 8 //對應jvm啓動參數-XX:SurvivorRatio=設置年輕代中Eden區與Survivor區的大小比值 
   PermSize         = 21757952 (20.75MB)  //對應jvm啓動參數-XX:PermSize=<value>:設置JVM堆的‘永生代’的初始大小
   MaxPermSize      = 85983232 (82.0MB)//對應jvm啓動參數-XX:MaxPermSize=<value>:設置JVM堆的‘永生代’的最大大小
   G1HeapRegionSize = 0 (0.0MB)

Heap Usage://堆內存使用情況
PS Young Generation
Eden Space://Eden區內存分佈
   capacity = 33030144 (31.5MB)//Eden區總容量
   used     = 1524040 (1.4534378051757812MB)  //Eden區已使用
   free     = 31506104 (30.04656219482422MB)  //Eden區剩餘容量
   4.614088270399305% used //Eden區使用比率
From Space:  //其中一個Survivor區的內存分佈
   capacity = 5242880 (5.0MB)
   used     = 0 (0.0MB)
   free     = 5242880 (5.0MB)
   0.0% used
To Space:  //另一個Survivor區的內存分佈
   capacity = 5242880 (5.0MB)
   used     = 0 (0.0MB)
   free     = 5242880 (5.0MB)
   0.0% used
PS Old Generation //當前的Old區內存分佈
   capacity = 86507520 (82.5MB)
   used     = 0 (0.0MB)
   free     = 86507520 (82.5MB)
   0.0% used
PS Perm Generation//當前的 “永生代” 內存分佈
   capacity = 22020096 (21.0MB)
   used     = 2496528 (2.3808746337890625MB)
   free     = 19523568 (18.619125366210938MB)
   11.337498256138392% used

670 interned Strings occupying 43720 bytes.

查看堆內存(histogram)中的對象數量及大小。執行命令： jmap -histo 3331

num     #instances         #bytes  class name
編號     個數                字節     類名
----------------------------------------------
   1:             7        1322080  [I
   2:          5603         722368  <methodKlass>
   3:          5603         641944  <constMethodKlass>
   4:         34022         544352  java.lang.Integer
   5:           371         437208  <constantPoolKlass>
   6:           336         270624  <constantPoolCacheKlass>
   7:           371         253816  <instanceKlassKlass>

將內存使用的詳細情況輸出到文件，執行命令： jmap -dump:format=b,file=heapDump 6900

然後用jhat命令可以參看 jhat -port 5000 heapDump 在瀏覽器中訪問：http://localhost:5000/ 查看詳細信息

這個命令執行，JVM會將整個heap的信息dump寫入到一個文件，heap如果比較大的話，就會導致這個過程比較耗時，並且執行的過程中爲了保證dump的信息是可靠的，所以會暫停應用。

總結

1.如果程序內存不足或者頻繁GC，很有可能存在內存泄露情況，這時候就要藉助Java堆Dump查看對象的情況。
2.要製作堆Dump可以直接使用jvm自帶的jmap命令
3.可以先使用jmap -heap命令查看堆的使用情況，看一下各個堆空間的佔用情況。
4.使用jmap -histo:[live]查看堆內存中的對象的情況。如果有大量對象在持續被引用，並沒有被釋放掉，那就產生了內存泄露，就要結合代碼，把不用的對象釋放掉。
5.也可以使用 jmap -dump:format=b,file=命令將堆信息保存到一個文件中，再借助jhat命令查看詳細內容
6.在內存出現泄露、溢出或者其它前提條件下，建議多dump幾次內存，把內存文件進行編號歸檔，便於後續內存整理分析。

出現問題：

Error attaching to process: sun.jvm.hotspot.debugger.DebuggerException: Can’t attach to the process
在ubuntu中第一次使用jmap會報錯：Error attaching to process: sun.jvm.hotspot.debugger.DebuggerException: Can't attach to the process，這是oracla文檔中提到的一個bug:http://bugs.java.com/bugdatabase/view_bug.do?bug_id=7050524,解決方式如下：

echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope 該方法在下次重啓前有效。
永久有效方法 sudo vi /etc/sysctl.d/10-ptrace.conf 編輯下面這行: kernel.yama.ptrace_scope = 1 修改爲: kernel.yama.ptrace_scope = 0 重啓系統，使修改生效。
趙小胖個人博客

5-JVM常用的命令

JVM常用的命令

jps ：基礎工具

jinfo：命令可以用來查看 Java 進程運行的 JVM 參數、

jstat：主要是對java應用程序的資源和性能進行實時的命令行監控，包括了對heap size和垃圾回收狀況的監控

jstack：查看某個Java進程內的線程堆棧信息

Jmap

什麼是堆Dump

基礎知識

總結

出現問題：

如何基於surging跨網關跨語言進行緩存降級

2024合集

程序員天天 CURD，怎麼才能成長，職業發展的思考(2)

移位操作搞定兩數之商

教你用Perl實現Smgp協議

如何通過前端表格控件在10分鐘內完成一張分組報表？

win11關閉自動檢測病毒刪文件

通用代碼生成器簡介

lightdb 單機模式下數據庫平移

千兆寬帶實際網速能到達多少？

PMP知識領域

PMP基本概念

Jenkins打Docker鏡像推送到私有倉庫

Jenkins集成SonarQube

MySQL數據和索引佔用空間查詢

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結