[JVM]虚拟机监控工具(命令行)

我会带着你远行 2022-05-09 06:50 383阅读 0赞

1.jps (Java Virtual Machine Process Status Tool)

用来查看基于HotSpot的JVM里面中，所有具有访问权限的Java进程的具体状态, 包括进程ID，进程启动的路径及启动参数等等，与unix上的ps类似，只不过jps是用来显示java进程，可以把jps理解为ps的一个子集。  
  
    jps \[options\] \[hostid\]  
    如果不指定hostid就默认为当前主机或服务器；如果指定了hostid，它就会显示指定hostid上面的java进程，不过这需要远程服务上开启了jstatd服务。  
  
    -q：忽略输出的类名、Jar名以及传递给main方法的参数，只输出pid。  
    -m：输出传递给main方法的参数，如果是内嵌的JVM则输出为null。  
    -l：输出完全的包名，应用主类名，jar的完全路径名  
    -v：输出传给jvm的参数  
    -V：输出通过标记的文件传递给JVM的参数（.hotspotrc文件，或者是通过参数-XX:Flags=指定的文件）。  
    -J 用于传递jvm选项到由javac调用的java加载器中，例如，“-J-Xms48m”将把启动内存设置为48M，使用-J选项可以非常方便的向基于Java的开发的底层虚拟机应用程序传递参数。  
  
    jps -mlv

1.  `9680 org.jetbrains.idea.maven.server.RemoteMavenServer -Djava.awt.headless=true -Didea.version==2017.1.1 -Xmx768m -Didea.maven.embedder.version=3.2.5 -Dfile.encoding=GBK`
2.  `2356 org.jetbrains.jps.cmdline.Launcher C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/lib/openapi.jar;C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/lib/jgoodies-forms.jar;C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/lib/javac2.jar;C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/lib/idea_rt.jar;C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/lib/jna-platform.jar;C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/lib/netty-all-4.1.9.Final.jar;C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/lib/protobuf-2.5.0.jar;C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/lib/annotations.jar;C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/lib/trove4j.jar;C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/lib/nanoxml-2.2.3.jar;C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/lib/forms_rt.jar;C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/lib/jdom.jar;C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/lib/asm-all.jar;C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/lib/jps-model.jar;C:/Program Files/JetBra -Xmx700m -Djava.awt.headless=true -Djava.endorsed.dirs="" -Djdt.compiler.useSingleThread=true -Dcompile.parallel=false -Drebuild.on.dependency.change=true -Djava.net.preferIPv4Stack=true -Dio.netty.initialSeedUniquifier=-8384703316530083662 -Dfile.encoding=GBK -Djps.file.types.component.name=FileTypeManager -Duser.language=zh -Duser.country=CN -Didea.paths.selector=IntelliJIdea2017.1 -Didea.home.path=C:\Program Files\JetBrains\IntelliJ IDEA 2017.1.1 -Didea.config.path=C:\Users\vincent\.IntelliJIdea2017.1\config -Didea.plugins.path=C:\Users\vincent\.IntelliJIdea2017.1\config\plugins -Djps.log.dir=C:/Users/vincent/.IntelliJIdea2017.1/system/log/build-log -Djps.fallback.jdk.home=C:/Program Files/JetBrains/IntelliJ IDEA 2017.1.1/jre64 -Djps.fallback.jdk.version=1.8.0_112-release -Dio.netty.noUnsafe=true -Djava.io.tmpdir=C:/Users/vincent/.IntelliJIdea2017.1/system/compile-server/es-demo_7a0f3d0f/_temp_ -Djps.backward.ref.index.builder=true -Dkotlin.incremental.compilation.experimental=true -Dkotlin.daemon.enabled`
3.  `4116  -Xms128m -Xmx750m -XX:ReservedCodeCacheSize=240m -XX:+UseConcMarkSweepGC -XX:SoftRefLRUPolicyMSPerMB=50 -ea -Dsun.io.useCanonCaches=false -Djava.net.preferIPv4Stack=true -XX:+HeapDumpOnOutOfMemoryError -XX:-OmitStackTraceInFastThrow -Djb.vmOptionsFile=C:\Program Files\JetBrains\IntelliJ IDEA 2017.1.1\bin\idea64.exe.vmoptions -Xbootclasspath/a:C:\Program Files\JetBrains\IntelliJ IDEA 2017.1.1\lib\boot.jar -Didea.jre.check=true -Didea.paths.selector=IntelliJIdea2017.1 -XX:ErrorFile=C:\Users\vincent\java_error_in_idea_%p.log -XX:HeapDumpPath=C:\Users\vincent\java_error_in_idea.hprof`
4.  `16776 sun.tools.jps.Jps -mlv -Denv.class.path=.;D:\jdk\lib\dt.jar;D:\jdk\lib\tools.jar;  -Dapplication.home=D:\jdk -Xms8m`

2. jstack

jstack主要用来查看某个Java进程内的线程堆栈信息。

jstack \[option\] pid    
    jstack \[option\] executable core    
    jstack \[option\] \[server-id@\]remote-hostname-or-ip  
  
    -l long listings，会打印出额外的锁信息，在发生死锁时可以用<strong>jstack -l pid</strong>来观察锁持有情况    
    -m mixed mode，不仅会输出Java堆栈信息，还会输出C/C++堆栈信息（比如Native方法）    
  
    jstack可以定位到线程堆栈，根据堆栈信息我们可以定位到具体代码，所以它在JVM性能调优中使用得非常多。下面我们来一个实例找出某个Java进程中最耗费CPU的Java线程并定位堆栈信息，用到的命令有ps、top、printf、jstack、grep。  
  
  第一步： 先找出Java进程ID，服务器上的Java应用名称为wordcount.jar：

1.  `root@ubuntu:/# ps -ef | grep mrf-center | grep -v grep`
2.  `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，我这里用第三个，输出如下：  
  
![70][]  
 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() [0x00007f94c6eda000]

可以看到CPU消耗在PollIntervalRetrySchedulerThread这个类的Object.wait()，我找了下我的代码，定位到下面的代码。

1.  `// Idle wait`
2.  `getLog().info("Thread [" + getName() + "] is idle waiting...");`
3.  `schedulerThreadState = PollTaskSchedulerThreadState.IdleWaiting;`
4.  `long now = System.currentTimeMillis();`
5.  `long waitTime = now + getIdleWaitTime();`
6.  `long timeUntilContinue = waitTime - now;`
7.  `synchronized(sigLock) {`
8.  `try {`
9.  `if(!halted.get()) {`
10. `sigLock.wait(timeUntilContinue);`
11. `}`
12. `}`
13. `catch (InterruptedException ignore) {`
14. `}`
15. `}`

它是轮询任务的空闲等待代码，上面的sigLock.wait(timeUntilContinue)就对应了前面的Object.wait()。

3. jmap（Memory Map）和jhat（Java Heap Analysis Tool）

jmap用来查看堆内存使用状况，一般结合jhat使用。  
   
  jmap语法格式如下：

1.  `jmap [option] pid`
2.  `jmap [option] executable core`
3.  `jmap [option] [server-id@]remote-hostname-or-ip`

如果运行在64位JVM上，可能需要指定-J-d64命令选项参数。  
  
（1） 打印进程的类加载器和类加载器加载的持久代对象信息，输出：类加载器名称、对象是否存活（不可靠）、对象地址、父类加载器、已加载的类大小等信息，如下图：  
  
     jmap -permstat pid  
  
![70 1][]  
（2） 使用jmap -heap pid查看进程堆内存使用情况，包括使用的GC算法、堆配置参数和各代中堆内存使用情况。比如下面的例子：  
  
    jmap -heap pid

1.  `[root@storm-master home]# jmap -heap 2860`
2.  `Attaching to process ID 2860, please wait...`
3.  `Debugger attached successfully.`
4.  `Server compiler detected.`
5.  `JVM version is 20.45-b01`
6.   
7.  `using thread-local object allocation.`
8.  `Mark Sweep Compact GC`
9.   
10. `Heap Configuration:`
11. `MinHeapFreeRatio = 40`
12. `MaxHeapFreeRatio = 70`
13. `MaxHeapSize = 257949696 (246.0MB)`
14. `NewSize = 1310720 (1.25MB)`
15. `MaxNewSize = 17592186044415 MB`
16. `OldSize = 5439488 (5.1875MB)`
17. `NewRatio = 2`
18. `SurvivorRatio = 8`
19. `PermSize = 21757952 (20.75MB)`
20. `MaxPermSize = 85983232 (82.0MB)`
21.  
22. `Heap Usage:`
23. `New Generation (Eden + 1 Survivor Space):`
24. `capacity = 12189696 (11.625MB)`
25. `used = 6769392 (6.4557952880859375MB)`
26. `free = 5420304 (5.1692047119140625MB)`
27. `55.53372290826613% used`
28. `Eden Space:`
29. `capacity = 10878976 (10.375MB)`
30. `used = 6585608 (6.280525207519531MB)`
31. `free = 4293368 (4.094474792480469MB)`
32. `60.53518272307982% used`
33. `From Space:`
34. `capacity = 1310720 (1.25MB)`
35. `used = 183784 (0.17527008056640625MB)`
36. `free = 1126936 (1.0747299194335938MB)`
37. `14.0216064453125% used`
38. `To Space:`
39. `capacity = 1310720 (1.25MB)`
40. `used = 0 (0.0MB)`
41. `free = 1310720 (1.25MB)`
42. `0.0% used`
43. `tenured generation:`
44. `capacity = 26619904 (25.38671875MB)`
45. `used = 15785896 (15.054603576660156MB)`
46. `free = 10834008 (10.332115173339844MB)`
47. `59.30110040967841% used`
48. `Perm Generation:`
49. `capacity = 33554432 (32.0MB)`
50. `used = 33323352 (31.779624938964844MB)`
51. `free = 231080 (0.22037506103515625MB)`
52. `99.31132793426514% used`

（3）查看堆内存中的对象数目、大小统计直方图，如果带上live则只统计活对象：  
      
        jmap -histo\[:live\] pid

1.  `root@ubuntu:/# jmap -histo:live 21711 | more`
2.   
3.  `num #instances #bytes class name`
4.  `----------------------------------------------`
5.  `1: 38445 5597736 <constMethodKlass>`
6.  `2: 38445 5237288 <methodKlass>`
7.  `3: 3500 3749504 <constantPoolKlass>`
8.  `4: 60858 3242600 <symbolKlass>`
9.  `5: 3500 2715264 <instanceKlassKlass>`
10. `6: 2796 2131424 <constantPoolCacheKlass>`
11. `7: 5543 1317400 [I`
12. `8: 13714 1010768 [C`
13. `9: 4752 1003344 [B`
14. `10: 1225 639656 <methodDataKlass>`
15. `11: 14194 454208 java.lang.String`
16. `12: 3809 396136 java.lang.Class`
17. `13: 4979 311952 [S`
18. `14: 5598 287064 [[I`
19. `15: 3028 266464 java.lang.reflect.Method`
20. `16: 280 163520 <objArrayKlassKlass>`
21. `17: 4355 139360 java.util.HashMap$Entry`
22. `18: 1869 138568 [Ljava.util.HashMap$Entry;`
23. `19: 2443 97720 java.util.LinkedHashMap$Entry`
24. `20: 2072 82880 java.lang.ref.SoftReference`
25. `21: 1807 71528 [Ljava.lang.Object;`
26. `22: 2206 70592 java.lang.ref.WeakReference`
27. `23: 934 52304 java.util.LinkedHashMap`
28. `24: 871 48776 java.beans.MethodDescriptor`
29. `25: 1442 46144 java.util.concurrent.ConcurrentHashMap$HashEntry`
30. `26: 804 38592 java.util.HashMap`
31. `27: 948 37920 java.util.concurrent.ConcurrentHashMap$Segment`
32. `28: 1621 35696 [Ljava.lang.Class;`
33. `29: 1313 34880 [Ljava.lang.String;`
34. `30: 1396 33504 java.util.LinkedList$Entry`
35. `31: 462 33264 java.lang.reflect.Field`
36. `32: 1024 32768 java.util.Hashtable$Entry`
37. `33: 948 31440 [Ljava.util.concurrent.ConcurrentHashMap$HashEntry;`

class name是对象类型，说明如下：

1.  `B byte`
2.  `C char`
3.  `D double`
4.  `F float`
5.  `I int`
6.  `J long`
7.  `Z boolean`
8.  `[ 数组，如[I表示int[]`
9.  `[L+类名 其他对象`

还有一个很常用的情况是：用jmap把进程内存使用情况dump到文件中，再用jhat分析查看。jmap进行dump命令格式如下：

jmap -dump:format=b,file=dumpFileName

一样地对上面进程ID为21711进行Dump：

1.  `root@ubuntu:/# jmap -dump:format=b,file=/tmp/dump.dat 21711`
2.  `Dumping heap to /tmp/dump.dat ...`
3.  `Heap dump file created`

dump出来的文件可以用MAT、VisualVM等工具查看，这里用jhat查看：

1.  `root@ubuntu:/# jhat -port 9998 /tmp/dump.dat`
2.  `Reading from /tmp/dump.dat...`
3.  `Dump file created Tue Jan 28 17:46:14 CST 2014`
4.  `Snapshot read, resolving...`
5.  `Resolving 132207 objects...`
6.  `Chasing references, expect 26 dots..........................`
7.  `Eliminating duplicate references..........................`
8.  `Snapshot resolved.`
9.  `Started HTTP server on port 9998`
10. `Server is ready.`

然后就可以在浏览器中输入主机地址:9998查看了：  
![70 2][]

4.jstat（JVM统计监测工具）

看看各个区内存和GC的情况

stat \[ generalOption | outputOptions vmid \[interval\[s|ms\] \[count\]\] \]    
    vmid是Java虚拟机ID，在Linux/Unix系统上一般就是进程ID。interval是采样时间间隔。count是采样数目。比如下面输出的是GC信息，采样时间间隔为250ms，采样数为6：

[root@storm-master Desktop]# jstat -gc 2860 250 6

![70 3][]

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总耗时

5.jinfo

jinfo是jdk自带的命令，用来查看jvm的配置参数。通常会先使用jps查看java进程的id，然后使用jinfo查看指定pid的jvm信息  
      
    jinfo -flags process\_id

jps

4704 Launcher
    9680 RemoteMavenServer
    4116
    13052 Jps

jinfo -flags 9680

1.  `Debugger attached successfully.`
2.  `Server compiler detected.`
3.  `JVM version is 25.91-b15`
4.  `Non-default VM flags: -XX:CICompilerCount=4 -XX:InitialHeapSize=268435456 -XX:MaxHeapSize=805306368 -XX:MaxNewSize=268435456 -XX:MinHeapDeltaBytes=524288 -XX:NewSize=89128960 -XX:OldSize=179306496 -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:+UseFastUnorderedTimeStamps -XX:-UseLargePagesIndividualAllocation -XX:+UseParallelGC`
5.  `Command line: -Djava.awt.headless=true -Didea.version==2017.1.1 -Xmx768m -Didea.maven.embedder.version=3.2.5 -Dfile.encoding=GBK`

6.hprof（Heap/CPU Profiling Tool）

hprof能够展现CPU使用率，统计堆内存使用情况。  
    2SE中提供了一个简单的命令行工具来对java程序的cpu和heap进行 profiling，叫做HPROF。HPROF实际上是JVM中的一个native的库，它会在JVM启动的时候通过命令行参数来动态加载，并成为 JVM进程的一部分。若要在java进程启动的时候使用HPROF，用户可以通过各种命令行参数类型来使用HPROF对java进程的heap或者 （和）cpu进行profiling的功能。HPROF产生的profiling数据可以是二进制的，也可以是文本格式的。这些日志可以用来跟踪和分析 java进程的性能问题和瓶颈，解决内存使用上不优的地方或者程序实现上的不优之处。二进制格式的日志还可以被JVM中的HAT工具来进行浏览和分析，用 以观察java进程的heap中各种类型和数据的情况。在J2SE 5.0以后的版本中，HPROF已经被并入到一个叫做Java Virtual Machine Tool Interface（JVM TI）中。

1.  `java -agentlib:hprof[=options] ToBeProfiledClass`
2.  `java -Xrunprof[:options] ToBeProfiledClass`
3.  `javac -J-agentlib:hprof[=options] ToBeProfiledClass`

1.  `Option Name and Value Description Default`
2.  `--------------------- ----------- -------`
3.  `heap=dump|sites|all heap profiling all`
4.  `cpu=samples|times|old CPU usage off`
5.  `monitor=y|n monitor contention n`
6.  `format=a|b text(txt) or binary output a`
7.  `file=<file> write data to file java.hprof[.txt]`
8.  `net=<host>:<port> send data over a socket off`
9.  `depth=<size> stack trace depth 4`
10. `interval=<ms> sample interval in ms 10`
11. `cutoff=<value> output cutoff point 0.0001`
12. `lineno=y|n line number in traces? y`
13. `thread=y|n thread in traces? n`
14. `doe=y|n dump on exit? y`
15. `msa=y|n Solaris micro state accounting n`
16. `force=y|n force output to <file> y`
17. `verbose=y|n print messages about dumps y`

\- Get sample cpu information every 20 millisec, with a stack depth of 3:   
         java -agentlib:hprof=cpu=samples,interval=20,depth=3 classname   
     - Get heap usage information based on the allocation sites:   
         java -agentlib:hprof=heap=sites classname   
      上面每隔20毫秒采样CPU消耗信息，堆栈深度为3，生成的profile文件名称是java.hprof.txt，在当前目录。   
      默认情况下，java进程profiling的信息（sites和dump）都会被 写入到一个叫做java.hprof.txt的文件中。大多数情况下，该文件中都会对每个trace，threads，objects包含一个ID，每一 个ID代表一个不同的观察对象。通常，traces会从300000开始。 默认，force=y，会将所有的信息全部输出到output文件中，所以如果含有 多个JVMs都采用的HRPOF enable的方式运行，最好将force=n，这样能够将单独的JVM的profiling信息输出到不同的指定文件。 interval选项只在 cpu=samples的情况下生效，表示每隔多少毫秒对java进程的cpu使用情况进行一次采集。 msa选项仅仅在Solaris系统下才有效， 表示会使用Solaris下的Micro State Accounting功能

[70]: /images/20220509/baf04d414a144f74994d142c841112f7.png
[70 1]: /images/20220509/4f9c84a46c784d78ac60ff6d831981f4.png
[70 2]: /images/20220509/6c8c4d1c9956405c818841802da338c4.png
[70 3]: /images/20220509/95e467adf90041d3bf7f22c543f5ee3f.png