zoukankan      html  css  js  c++  java
  • JVM监控命令


    原博客路径:https://www.cnblogs.com/rainy-shurun/p/5732341.html

      JDK本身提供了很多方便的JVM性能调优监控工具,除了集成式的VisualVM和jConsole外,还有jps、jstack、jmap、jhat、jstat等小巧的工具。

        现实企业级Java开发中,有时候我们会碰到下面这些问题:

    • OutOfMemoryError,内存不足

    • 内存泄露

    • 线程死锁、死循环等

    • Java进程消耗CPU过高

    • .系统挂起无响应

    • 系统运行越来越慢
    • 系统挂起无响应
    • 由于线程数量太多导致内存溢出(如无法创建线程等等)

    A、 jps(Java Virtual Machine Process Status Tool)      

        jps主要用来输出JVM中运行的进程状态信息。语法格式如

      1 jps [options]  [hostid]

     命令行参数选项说明如下:    如果不指定hostid就默认为当前主机或服务器。

    1 -q 不输出类名、Jar名和传入main方法的参数
    2 -m 输出传入main方法的参数
    3 -l 输出main类或Jar的全限名
    4 -v 输出传入JVM的参数


    比如下面:

    1 root@ubuntu:/# jps -m -l
    2 2458 org.artifactory.standalone.main.Main /usr/local/artifactory-2.2.5/etc/jetty.xml
    3 29920 com.sun.tools.hat.Main -port 9998 /tmp/dump.dat
    4 3149 org.apache.catalina.startup.Bootstrap start
    5 30972 sun.tools.jps.Jps -m -l
    6 8247 org.apache.catalina.startup.Bootstrap start
    7 25687 com.sun.tools.hat.Main -port 9999 dump.dat
    8 21711 mrf-center.jar

     
    B、 jstack

        jstack主要用来查看某个Java进程内的线程堆栈信息。可以分析除了内存泄露之外的其他任何问题,比如:        

      1、系统无缘无故的cpu过高
      2、系统挂起,无响应
      3、系统运行越来越慢
      4、性能瓶颈(如无法充分利用cpu等)
      5、线程死锁,死循环等
      6、由于线程数量太多导致的内存溢出(如无法创建线程等)

      所以线程栈是分析jvm虚拟机中常用到的,也就是jstack会是我们以后工作中常用到的命令。在具体分析的时候因为线程栈是瞬时快照包含线程状态以及调用关系,所以借助堆栈信息可以帮助分析很多问题,比如线程死锁,锁争用,死循环,识别耗时操作等等。线程栈是瞬时记录,所以没有历史消息的回溯,一般我们都需要结合程序的日志进行跟踪

      下面来科普下啥是线程栈:

        (1)什么是线程栈?

          线程堆栈也称线程调用堆栈,是虚拟机中线程(包括锁)状态的一个瞬间状态的快照,即系统在某一个时刻所有线程的运行状态,包括每一个线程的调用堆栈,锁的持有情况。

        (2)、线程栈包含的3个方面

          线程名字,id,线程的数量等。
          线程的运行状态,锁的状态(锁被哪个线程持有,哪个线程在等待锁等)
          调用堆栈(即函数的调用层次关系)调用堆栈包含完整的类名,所执行的方法,源代码的行数

          一个例子:

      

      (3)、线程栈的7种状态

          1、NEW

          2、RUNNABLE

          3、RUNNING

          4、BLOCKED

          5、WAITING

          6、TIMED_WAITING

          7、TERMINATED

        

           jstack可以定位到线程堆栈,根据堆栈信息我们可以定位到具体代码,所以它在JVM性能调优中使用得非常多。下面我们来一个实例找出某个Java进程中最耗费CPU的Java线程并定位堆栈信息,用到的命令有ps、top、jstack、grep。

       

      第一步先找出Java进程ID,我部署在服务器上的Java应用名称为mrf-center: 得到进程ID为21711,第二步找出该进程内最耗费CPU的线程,可以使用ps -Lfp pid或者ps -mp pid -o THREAD, tid, time或者top -Hp pid,我这里用第三个,输出如下:

    JVM性能调优监控工具jps、jstack、jmap、jhat、jstat使用详解

        TIME列就是各个Java线程耗费的CPU时间,CPU时间最长的是线程ID为21742的线程,用

         printf "%x " 21742 ,得到21742的十六进制值为54ee,下面会用到。    

        OK,下一步终于轮到jstack上场了,它用来输出进程21711的堆栈信息,然后根据线程ID的十六进制值grep,如下:

    1 root@ubuntu:/# jstack 21711 | grep 54ee
    2 "PollIntervalRetrySchedulerThread" prio=10 tid=0x00007f950043e000 nid=0x54ee in Object.wait() [0x00007f94c6eda000]

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

    01 // Idle wait
    02 getLog().info("Thread [" + getName() + "] is idle waiting...");
    03 schedulerThreadState = PollTaskSchedulerThreadState.IdleWaiting;
    04 long now = System.currentTimeMillis();
    05 long waitTime = now + getIdleWaitTime();
    06 long timeUntilContinue = waitTime - now;
    07 synchronized(sigLock) {
    08 try {
    09 if(!halted.get()) {
    10 sigLock.wait(timeUntilContinue);
    11 }
    12 }
    13 catch (InterruptedException ignore) {
    14 }

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

    C、 jmap(Memory Map)和jhat(Java Heap Analysis Tool)

          jmap用来查看堆内存使用状况,用于分析内存溢出的问题,常常结合jhat使用。

    • 使用jmap -heap pid(java进程)查看进程堆内存使用情况,包括使用的GC算法、堆配置参数和各代中堆内存使用情况。这个不常用。
    •     使用jmap -histo[:live] pid查看堆内存中的对象数目、大小统计直方图,如果带上live则只统计活对象,利用这个命令查找与项目有关的类,与项目有关的一般在类前面会有公司项目有关的包名,比如这里的cn.test.TestBean
              

     class name是对象类型,说明如下:

    B byte
    C char
    D double
    F float
    I int
    J long
    Z boolean
    [ 数组,如[I表示int[]
    [L+类名 其他对象

      还有一种会遇到的情况是在前面没有找到与项目有关的使用项目有关的类,这个时候就要使用jmap -dump命令了,但是不要开始就要这个命令,因为这个命令会触发full  gc把内存清理部分。

        当用jmap把进程内存使用情况dump到文件中后,后面再用jhat分析查看。jmap进行dump命令格式如下:

    B byte
    C char
    D double
    F float
    I int
    J long
    Z boolean
    [ 数组,如[I表示int[]
    [L+类名 其他对象

      我们对java进程ID为21711进行Dump:      jmap -dump:live,format=b,file=heap.bin 21711(java进程id)

           dump出来的文件可以用MAT、VisualVM等工具查看,这里用jhat查看dump出来的文件:
        jhat  -J -mv800m  heap.bin   这里的-J就是指增加内存的意思  这里是增加虚拟机堆内存800m
      然后就可以在浏览器中输入主机地址:9998查看了:

    JVM性能调优监控工具jps、jstack、jmap、jhat、jstat使用详解

        上面红线框出来的部分大家可以自己去摸索下,最后一项支持OQL(对象查询语言)。

    D、jstat(JVM统计监测工具)

        语法格式如下:

    1 jstat [ generalOption | outputOptions vmid [interval[s|ms] [count]] ]

        vmid是虚拟机ID,在Linux/Unix系统上一般就是进程ID。interval是采样时间间隔。count是采样数目。比如下面输出的是GC信息,采样时间间隔为250ms,采样数为4:

    1 root@ubuntu:/# jstat -gc 21711 250 4
    2  S0C    S1C    S0U    S1U      EC       EU        OC         OU       PC     PU    YGC     YGCT    FGC    FGCT     GCT   
    3 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
    4 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
    5 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
    6 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堆内存布局:

    JVM性能调优监控工具jps、jstack、jmap、jhat、jstat使用详解

        从图可以看出:

    堆内存 = 年轻代 + 年老代 + 永久代
    年轻代 = 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总耗时

    对应参数解释:

    各种 Java Thread State 第一分析法则

    使用 TDA 工具,看到大量 Java Thread State 的第一反应是:

    1,线程状态为“waiting for monitor entry”:
    意味着它 在等待进入一个临界区 ,所以它在”Entry Set“队列中等待。
    此时线程状态一般都是 Blocked:
    • java.lang.Thread.State: BLOCKED (on object monitor)
    2,线程状态为“waiting on condition”:
    说明它在等待另一个条件的发生,来把自己唤醒,或者干脆它是调用了 sleep(N)。
    此时线程状态大致为以下几种:
    • java.lang.Thread.State: WAITING (parking):一直等那个条件发生;
    • java.lang.Thread.State: TIMED_WAITING (parking或sleeping):定时的,那个条件不到来,也将定时唤醒自己。

     
    3,如果大量线程在“waiting for monitor entry”:
    可能是一个全局锁阻塞住了大量线程。
    如果短时间内打印的 thread dump 文件反映,随着时间流逝,waiting for monitor entry 的线程越来越多,没有减少的趋势,可能意味着某些线程在临界区里呆的时间太长了,以至于越来越多新线程迟迟无法进入临界区
     
     
     
    4,如果大量线程在waiting on condition”:
    可能是它们又跑去获取第三方资源,尤其是第三方网络资源,迟迟获取不到Response,导致大量线程进入等待状态。
    所以如果你发现有大量的线程都处在 Wait on condition,从线程堆栈看,正等待网络读写,这可能是一个网络瓶颈的征兆,因为网络阻塞导致线程无法执行。
     

    线程状态为“in Object.wait()”:
    说明它获得了监视器之后,又调用了 java.lang.Object.wait() 方法
    每个 Monitor在某个时刻,只能被一个线程拥有,该线程就是 “Active Thread”,而其它线程都是 “Waiting Thread”,分别在两个队列 “ Entry Set”和 “Wait Set”里面等候。在 “Entry Set”中等待的线程状态是 “Waiting for monitor entry”,而在 “Wait Set”中等待的线程状态是 “in Object.wait()”。
    当线程获得了 Monitor,如果发现线程继续运行的条件没有满足,它则调用对象(一般就是被 synchronized 的对象)的 wait() 方法,放弃了 Monitor,进入 “Wait Set”队列。
    此时线程状态大致为以下几种:
    • java.lang.Thread.State: TIMED_WAITING (on object monitor);
    • java.lang.Thread.State: WAITING (on object monitor);
    一般都是RMI相关线程(RMI RenewClean、 GC Daemon、RMI Reaper),GC线程(Finalizer),引用对象垃圾回收线程(Reference Handler)等系统线程处于这种状态。
     
    Java Monitor
     
    图1 A Java Monitor
     
    示范一:
    下面这个线程在等待这个锁 0x00000000fe7e3b50,等待进入临界区:
    "RMI TCP Connection(64896)-172.16.52.118" daemon prio=10 tid=0x00000000405a6000 nid=0x68fe waiting for monitor entry [0x00007f2be65a3000]
       java.lang.Thread.State: BLOCKED (on object monitor)
    at com.xyz.goods.service.impl.GoodsServiceImpl.findChanellGoodsCountWithCache(GoodsServiceImpl.java:1734)
    waiting to lock <0x00000000fe7e3b50> (a java.lang.String)

    那么谁持有这个锁呢?
    是另一个先调用了 findChanellGoodsCountWithCache 函数的线程:
    "RMI TCP Connection(64878)-172.16.52.117" daemon prio=10 tid=0x0000000040822000 nid=0x6841 runnable [0x00007f2be76b3000]
       java.lang.Thread.State: RUNNABLE
    at java.net.SocketInputStream.socketRead0(Native Method)
    at java.net.SocketInputStream.read(SocketInputStream.java:129)
    at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
    at java.io.BufferedInputStream.read1(BufferedInputStream.java:258)
    at java.io.BufferedInputStream.read(BufferedInputStream.java:317)
    - locked <0x00000000af4ed638> (a java.io.BufferedInputStream)
    at org.bson.io.Bits.readFully(Bits.java:35)
    at org.bson.io.Bits.readFully(Bits.java:28)
    at com.mongodb.Response.<init>(Response.java:35)
    at com.mongodb.DBPort.go(DBPort.java:110)
    - locked <0x00000000af442d48> (a com.mongodb.DBPort)
    at com.mongodb.DBPort.go(DBPort.java:75)
    - locked <0x00000000af442d48> (a com.mongodb.DBPort)
    at com.mongodb.DBPort.call(DBPort.java:65)
    at com.mongodb.DBTCPConnector.call(DBTCPConnector.java:202)
    at com.mongodb.DBApiLayer$MyCollection.__find(DBApiLayer.java:296)
    at com.mongodb.DB.command(DB.java:152)
    at com.mongodb.DBCollection.getCount(DBCollection.java:760)
    at com.mongodb.DBCollection.getCount(DBCollection.java:731)
    at com.mongodb.DBCollection.count(DBCollection.java:697)
    at com.xyz.goods.manager.MongodbManager.count(MongodbManager.java:202)
    at com.xyz.goods.service.impl.GoodsServiceImpl.findChanellGoodsCount(GoodsServiceImpl.java:1787)
    at com.xyz.goods.service.impl.GoodsServiceImpl.findChanellGoodsCountWithCache(GoodsServiceImpl.java:1739)
    locked <0x00000000fe7e3b50> (a java.lang.String)
    示范二:
    等待另一个条件发生来将自己唤醒:
    "RMI TCP Connection(idle)" daemon prio=10 tid=0x00007fd50834e800 nid=0x56b2 waiting on condition [0x00007fd4f1a59000]
       java.lang.Thread.State: TIMED_WAITING (parking)
    at sun.misc.Unsafe.park(Native Method)
    parking to wait for  <0x00000000acd84de8> (a java.util.concurrent.SynchronousQueue$TransferStack)
    at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:198)
    at java.util.concurrent.SynchronousQueue$TransferStack.awaitFulfill(SynchronousQueue.java:424)
    at java.util.concurrent.SynchronousQueue$TransferStack.transfer(SynchronousQueue.java:323)
    at java.util.concurrent.SynchronousQueue.poll(SynchronousQueue.java:874)
    at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:945)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:907)
    at java.lang.Thread.run(Thread.java:662)
    1)“TIMED_WAITING (parking)”中的 timed_waiting 指等待状态,但这里指定了时间,到达指定的时间后自动退出等待状态;parking指线程处于挂起中。
    2)“waiting on condition”需要与堆栈中的“parking to wait for  <0x00000000acd84de8> (a java.util.concurrent.SynchronousQueue$TransferStack)” 结合来看。首先,本线程肯定是在等待某个条件的发生,来把自己唤醒。其次,SynchronousQueue 并不是一个队列,只是线程之间移交信息的机制,当我们把一个元素放入到 SynchronousQueue 中时必须有另一个线程正在等待接受移交的任务,因此这就是本线程在等待的条件。
     
    示范三:
    "RMI RenewClean-[172.16.50.182:4888]" daemon prio=10 tid=0x0000000040d2c800 nid=0x97e in Object.wait() [0x00007f9ccafd0000]
       java.lang.Thread.State: TIMED_WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x0000000799b032d8> (a java.lang.ref.ReferenceQueue$Lock)
    at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:118)
    - locked <0x0000000799b032d8> (a java.lang.ref.ReferenceQueue$Lock)
    at sun.rmi.transport.DGCClient$EndpointEntry$RenewCleanThread.run(DGCClient.java:516)
    at java.lang.Thread.run(Thread.java:662)
     
     
     
     
     
  • 相关阅读:
    SDN课程阅读作业(2)
    2019 SDN上机第5次作业
    linux 最常用命令
    tomcat 部署 React 项目后,浏览器刷新报404问题
    Java8 ~ 特性
    React ~ 小结
    ES6 map与filter
    Idea 快捷键
    实现div可以调整高度(div实现resize)
    linux常用命令(4)
  • 原文地址:https://www.cnblogs.com/zpbk1991/p/8608541.html
Copyright © 2011-2022 走看看