小蜜蜂

小蜜蜂

关注
发信
关注(|-)粉丝(-|)

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

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，我这里用第三个，输出如下：

[JVM]虚拟机监控工具(命令行)-LMLPHP
 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

[JVM]虚拟机监控工具(命令行)-LMLPHP
（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查看了：
[JVM]虚拟机监控工具(命令行)-LMLPHP
 

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

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

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功能

10-03 18:48
Powered by LMLPHP ©2024 小蜜蜂 0.053173