精华内容
下载资源
问答
  • java性能分析 jmap jstack

    2018-08-06 19:58:11
    java程序性能分析thread dumpheap dump,dump文件:在故障定位(尤其是out of memory)性能分析的时候,dump文件记录了JVM运行期间的内存占用、线程执行等情况。 heap dump:记录某一时刻JVM堆中对象使用情况,哪些...
  • jmap和jstack的使用详解

    千次阅读 2018-09-05 16:07:37
    Java堆栈的区别 ** 栈与堆都是Java用来在Ram中存放数据的地方。与C++不同,Java自动管理栈堆,程序员不能直接地设置栈或堆。 Java的堆是一个运行时数据区,类的对象从中分配空间。这些对象通过new、newarray...

    **

    Java堆和栈的区别

    **

    栈与堆都是Java用来在Ram中存放数据的地方。与C++不同,Java自动管理栈和堆,程序员不能直接地设置栈或堆。
    Java的堆是一个运行时数据区,类的对象从中分配空间。这些对象通过new、newarray、anewarray和 multianewarray等指令建立,它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的,堆的优势是可以动态地分配内存大小,生存期也不必事先告诉编译器,因为它是在运行时动态分配内存的,Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是,由于要在运行时动态分配内存,存取速度较慢。

    栈的优势是,存取速度比堆要快,仅次于寄存器,栈数据可以共享。但缺点是,存在栈中的数据大小与生存期必须是确定的,缺乏灵活性。

    栈中主要存放一些基本类型的变量(,int, short, long, byte, float, double, boolean, char)和对象句柄。
    栈有一个很重要的特殊性,就是存在栈中的数据可以共享。假设我们同时定义:
    int a = 3;
    int b = 3;
    编译器先处理int a = 3;首先它会在栈中创建一个变量为a的引用,然后查找栈中是否有3这个值,如果没找到,就将3存放进来,然后将a指向3。接着处理int b = 3;在创建完b的引用变量后,因为在栈中已经有3这个值,便将b直接指向3。这样,就出现了a与b同时均指向3的情况。
    这时,如果再令a=4;那么编译器会重新搜索栈中是否有4值,如果没有,则将4存放进来,并令a指向4;如果已经有了,则直接将a指向这个地址。因此a值的改变不会影响到b的值。
    要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的,因为这种情况a的修改并不会影响到b, 它是由编译器完成的,它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态,会影响到另一个对象引用变量。

    A、 jps(Java Virtual Machine Process Status Tool)

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

    jps [options] [hostid]
    如果不指定hostid就默认为当前主机或服务器。

    命令行参数选项说明如下:
    

    -q 不输出类名、Jar名和传入main方法的参数
    -m 输出传入main方法的参数
    -l 输出main类或Jar的全限名
    -v 输出传入JVM的参数
    比如下面:

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

    B、 jstack

    jstack主要用来查看某个Java进程内的线程堆栈信息。语法格式如下:
    

    jstack [option] pid
    jstack [option] executable core
    jstack [option] [server-id@]remote-hostname-or-ip
    命令行参数选项说明如下:

    -l long listings,会打印出额外的锁信息,在发生死锁时可以用jstack -l pid来观察锁持有情况
    -m mixed mode,不仅会输出Java堆栈信息,还会输出C/C++堆栈信息(比如Native方法)
    jstack可以定位到线程堆栈,根据堆栈信息我们可以定位到具体代码,所以它在JVM性能调优中使用得非常多。下面我们来一个实例找出某个Java进程中最耗费CPU的Java线程并定位堆栈信息,用到的命令有ps、top、printf、jstack、grep。

    第一步先找出Java进程ID,我部署在服务器上的Java应用名称为mrf-center:
    
    root@ubuntu:/# ps -ef | grep mrf-center | grep -v grep
    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性能调优监控工具jps、jstack、jmap、jhat、jstat使用详解

    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(),我找了下我的代码,定位到下面的代码:
    
    // Idle wait  
    getLog().info("Thread [" + getName() + "] is idle waiting...");  
    schedulerThreadState = PollTaskSchedulerThreadState.IdleWaiting;  
    long now = System.currentTimeMillis();  
    long waitTime = now + getIdleWaitTime();  
    long timeUntilContinue = waitTime - now;  
    synchronized(sigLock) {  
        try {  
            if(!halted.get()) {  
                sigLock.wait(timeUntilContinue);  
            }  
        }   
        catch (InterruptedException ignore) {  
        }  
    }  
    它是轮询任务的空闲等待代码,上面的sigLock.wait(timeUntilContinue)就对应了前面的Object.wait()。
    

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

    jmap用来查看堆内存使用状况,一般结合jhat使用。
    
    jmap语法格式如下:
    
    jmap [option] pid
    jmap [option] executable core
    jmap [option] [server-id@]remote-hostname-or-ip
    如果运行在64位JVM上,可能需要指定-J-d64命令选项参数。
    

    jmap -permstat pid
    打印进程的类加载器和类加载器加载的持久代对象信息,输出:类加载器名称、对象是否存活(不可靠)、对象地址、父类加载器、已加载的类大小等信息,如下图:

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

    使用jmap -heap pid查看进程堆内存使用情况,包括使用的GC算法、堆配置参数和各代中堆内存使用情况。比如下面的例子:

    root@ubuntu:/# jmap -heap 21711
    Attaching to process ID 21711, please wait...
    Debugger attached successfully.
    Server compiler detected.
    JVM version is 20.10-b01
    
    using thread-local object allocation.
    Parallel GC with 4 thread(s)
    
    Heap Configuration:
       MinHeapFreeRatio = 40
       MaxHeapFreeRatio = 70
       MaxHeapSize      = 2067791872 (1972.0MB)
       NewSize          = 1310720 (1.25MB)
       MaxNewSize       = 17592186044415 MB
       OldSize          = 5439488 (5.1875MB)
       NewRatio         = 2
       SurvivorRatio    = 8
       PermSize         = 21757952 (20.75MB)
       MaxPermSize      = 85983232 (82.0MB)
    
    Heap Usage:
    PS Young Generation
    Eden Space:
       capacity = 6422528 (6.125MB)
       used     = 5445552 (5.1932830810546875MB)
       free     = 976976 (0.9317169189453125MB)
       84.78829520089286% used
    From Space:
       capacity = 131072 (0.125MB)
       used     = 98304 (0.09375MB)
       free     = 32768 (0.03125MB)
       75.0% used
    To Space:
       capacity = 131072 (0.125MB)
       used     = 0 (0.0MB)
       free     = 131072 (0.125MB)
       0.0% used
    PS Old Generation
       capacity = 35258368 (33.625MB)
       used     = 4119544 (3.9287033081054688MB)
       free     = 31138824 (29.69629669189453MB)
       11.683876009235595% used
    PS Perm Generation
       capacity = 52428800 (50.0MB)
       used     = 26075168 (24.867218017578125MB)
       free     = 26353632 (25.132781982421875MB)
       49.73443603515625% used
       ....
    使用jmap -histo[:live] pid查看堆内存中的对象数目、大小统计直方图,如果带上live则只统计活对象,如下:
    
    root@ubuntu:/# jmap -histo:live 21711 | more
     num     #instances         #bytes  class name
    ----------------------------------------------
       1:         38445        5597736  <constMethodKlass>
       2:         38445        5237288  <methodKlass>
       3:          3500        3749504  <constantPoolKlass>
       4:         60858        3242600  <symbolKlass>
       5:          3500        2715264  <instanceKlassKlass>
       6:          2796        2131424  <constantPoolCacheKlass>
       7:          5543        1317400  [I
       8:         13714        1010768  [C
       9:          4752        1003344  [B
      10:          1225         639656  <methodDataKlass>
      11:         14194         454208  java.lang.String
      12:          3809         396136  java.lang.Class
      13:          4979         311952  [S
      14:          5598         287064  [[I
      15:          3028         266464  java.lang.reflect.Method
      16:           280         163520  <objArrayKlassKlass>
      17:          4355         139360  java.util.HashMap$Entry
      18:          1869         138568  [Ljava.util.HashMap$Entry;
      19:          2443          97720  java.util.LinkedHashMap$Entry
      20:          2072          82880  java.lang.ref.SoftReference
      21:          1807          71528  [Ljava.lang.Object;
      22:          2206          70592  java.lang.ref.WeakReference
      23:           934          52304  java.util.LinkedHashMap
      24:           871          48776  java.beans.MethodDescriptor
      25:          1442          46144  java.util.concurrent.ConcurrentHashMap$HashEntry
      26:           804          38592  java.util.HashMap
      27:           948          37920  java.util.concurrent.ConcurrentHashMap$Segment
      28:          1621          35696  [Ljava.lang.Class;
      29:          1313          34880  [Ljava.lang.String;
      30:          1396          33504  java.util.LinkedList$Entry
      31:           462          33264  java.lang.reflect.Field
      32:          1024          32768  java.util.Hashtable$Entry
      33:           948          31440  [Ljava.util.concurrent.ConcurrentHashMap$HashEntry;
    class name是对象类型,说明如下:
    
    B  byte
    C  char
    D  double
    F  float
    I  int
    J  long
    Z  boolean

    [ 数组,如[I表示int[]
    [L+类名 其他对象
    还有一个很常用的情况是:用jmap把进程内存使用情况dump到文件中,再用jhat分析查看。jmap进行dump命令格式如下:

    jmap -dump:format=b,file=dumpFileName
    我一样地对上面进程ID为21711进行Dump:
    
    root@ubuntu:/# jmap -dump:format=b,file=/tmp/dump.dat 21711     
    Dumping heap to /tmp/dump.dat ...
    Heap dump file created

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

    root@ubuntu:/# jhat -port 9998 /tmp/dump.dat
    Reading from /tmp/dump.dat...
    Dump file created Tue Jan 28 17:46:14 CST 2014
    Snapshot read, resolving...
    Resolving 132207 objects...
    Chasing references, expect 26 dots..........................
    Eliminating duplicate references..........................
    Snapshot resolved.
    Started HTTP server on port 9998
    Server is ready.
     然后就可以在浏览器中输入主机地址:9998查看了:
    

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

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

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

    语法格式如下:
    
    jstat [ generalOption | outputOptions vmid [interval[s|ms] [count]] ]
    vmid是虚拟机ID,在Linux/Unix系统上一般就是进程ID。interval是采样时间间隔。count是采样数目。比如下面输出的是GC信息,采样时间间隔为250ms,采样数为4:
    
    root@ubuntu:/# jstat -gc 21711 250 4
     S0C    S1C    S0U    S1U      EC       EU        OC         OU       PC     PU    YGC     YGCT    FGC    FGCT     GCT   
    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
    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
    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
    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总耗时

    其他JVM性能调优参考资料:

    《Java虚拟机规范》

    《Java Performance》

    《Trouble Shooting Guide for JavaSE 6 with HotSpot VM》: http://www.oracle.com/technetwork/java/javase/tsg-vm-149989.pdf

    《Effective Java》

    VisualVM: http://docs.oracle.com/javase/7/docs/technotes/guides/visualvm/

    jConsole: http://docs.oracle.com/javase/1.5.0/docs/guide/management/jconsole.html

    Monitoring and Managing JavaSE 6 Applications: http://www.oracle.com/technetwork/articles/javase/monitoring-141801.html

    jstack信息分析

    Full thread dump Java HotSpot(TM) 64-Bit Server VM (24.71-b01 mixed mode):  
    
    "Attach Listener" daemon prio=10 tid=0x00007f75a4001000 nid=0x947 waiting on condition [0x0000000000000000]  
       java.lang.Thread.State: RUNNABLE  
    
    "LeaseRenewer:hive@nameservice1" daemon prio=10 tid=0x00007f7364f5a000 nid=0x537 waiting on condition [0x00007f713407f000]  
       java.lang.Thread.State: TIMED_WAITING (sleeping)  
        at java.lang.Thread.sleep(Native Method)  
        at org.apache.hadoop.hdfs.LeaseRenewer.run(LeaseRenewer.java:438)  
        at org.apache.hadoop.hdfs.LeaseRenewer.access$700(LeaseRenewer.java:71)  
        at org.apache.hadoop.hdfs.LeaseRenewer$1.run(LeaseRenewer.java:298)  
        at java.lang.Thread.run(Thread.java:745)  
    
    "HiveServer2-Handler-Pool: Thread-883126" prio=10 tid=0x00007f73bc016000 nid=0x4e5 waiting on condition [0x00007f7137bba000]  
       java.lang.Thread.State: TIMED_WAITING (parking)  
        at sun.misc.Unsafe.park(Native Method)  
        - parking to wait for  <0x00000006585a35d8> (a java.util.concurrent.SynchronousQueue$TransferStack)  
        at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)  
        at java.util.concurrent.SynchronousQueue$TransferStack.awaitFulfill(SynchronousQueue.java:460)  
        at java.util.concurrent.SynchronousQueue$TransferStack.transfer(SynchronousQueue.java:359)  
        at java.util.concurrent.SynchronousQueue.poll(SynchronousQueue.java:942)  
        at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1068)  
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1130)  
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)  
        at java.lang.Thread.run(Thread.java:745)  
    
    "IPC Parameter Sending Thread #729" daemon prio=10 tid=0x00007f7364f59000 nid=0x73cc waiting on condition [0x00007f712c302000]  
       java.lang.Thread.State: TIMED_WAITING (parking)  
        at sun.misc.Unsafe.park(Native Method)  
        - parking to wait for  <0x0000000656680e10> (a java.util.concurrent.SynchronousQueue$TransferStack)  
        at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)  
        at java.util.concurrent.SynchronousQueue$TransferStack.awaitFulfill(SynchronousQueue.java:460)  
        at java.util.concurrent.SynchronousQueue$TransferStack.transfer(SynchronousQueue.java:359)  
        at java.util.concurrent.SynchronousQueue.poll(SynchronousQueue.java:942)  
        at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1068)  
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1130)  
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)  
        at java.lang.Thread.run(Thread.java:745)  
    
    "HiveServer2-Handler-Pool: Thread-882656" prio=10 tid=0x00007f73bc013000 nid=0x497a waiting on condition [0x00007f712cc0b000]  
       java.lang.Thread.State: TIMED_WAITING (parking)  
        at sun.misc.Unsafe.park(Native Method)  
        - parking to wait for  <0x00000006585a35d8> (a java.util.concurrent.SynchronousQueue$TransferStack)  
        at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)  
        at java.util.concurrent.SynchronousQueue$TransferStack.awaitFulfill(SynchronousQueue.java:460)  
        at java.util.concurrent.SynchronousQueue$TransferStack.transfer(SynchronousQueue.java:359)  
        at java.util.concurrent.SynchronousQueue.poll(SynchronousQueue.java:942)  
        at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1068)  
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1130)  
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)  
        at java.lang.Thread.run(Thread.java:745)  
    
    "qtp931145444-882653" daemon prio=10 tid=0x00007f747401c000 nid=0x3376 waiting on condition [0x00007f7137dbc000]  
       java.lang.Thread.State: TIMED_WAITING (parking)  
        at sun.misc.Unsafe.park(Native Method)  
        - parking to wait for  <0x0000000657459540> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)  
        at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)  
        at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2082)  
        at org.eclipse.jetty.util.BlockingArrayQueue.poll(BlockingArrayQueue.java:342)  
        at org.eclipse.jetty.util.thread.QueuedThreadPool.idleJobPoll(QueuedThreadPool.java:526)  
        at org.eclipse.jetty.util.thread.QueuedThreadPool.access$600(QueuedThreadPool.java:44)  
        at org.eclipse.jetty.util.thread.QueuedThreadPool$3.run(QueuedThreadPool.java:572)  
        at java.lang.Thread.run(Thread.java:745)  
    
    "qtp931145444-882456" daemon prio=10 tid=0x00007f7470001000 nid=0x9600 waiting on condition [0x00007f7133776000]  
       java.lang.Thread.State: TIMED_WAITING (parking)  
        at sun.misc.Unsafe.park(Native Method)  
        - parking to wait for  <0x0000000657459540> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)  
        at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)  
        at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2082)  
        at org.eclipse.jetty.util.BlockingArrayQueue.poll(BlockingArrayQueue.java:342)  
        at org.eclipse.jetty.util.thread.QueuedThreadPool.idleJobPoll(QueuedThreadPool.java:526)  
        at org.eclipse.jetty.util.thread.QueuedThreadPool.access$600(QueuedThreadPool.java:44)  
        at org.eclipse.jetty.util.thread.QueuedThreadPool$3.run(QueuedThreadPool.java:572)  
        at java.lang.Thread.run(Thread.java:745)  
    
    "qtp931145444-882454" daemon prio=10 tid=0x00007f7454005800 nid=0x8ca1 waiting on condition [0x00007f713508f000]  
       java.lang.Thread.State: TIMED_WAITING (parking)  
        at sun.misc.Unsafe.park(Native Method)  
        - parking to wait for  <0x0000000657459540> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)  
        at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)  
        at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2082)  
        at org.eclipse.jetty.util.BlockingArrayQueue.poll(BlockingArrayQueue.java:342)  
        at org.eclipse.jetty.util.thread.QueuedThreadPool.idleJobPoll(QueuedThreadPool.java:526)  
        at org.eclipse.jetty.util.thread.QueuedThreadPool.access$600(QueuedThreadPool.java:44)  
        at org.eclipse.jetty.util.thread.QueuedThreadPool$3.run(QueuedThreadPool.java:572)  
        at java.lang.Thread.run(Thread.java:745)  
    
    "qtp931145444-881328" daemon prio=10 tid=0x00007f746c001800 nid=0x184c waiting on condition [0x00007f713306f000]  
       java.lang.Thread.State: TIMED_WAITING (parking)  
        at sun.misc.Unsafe.park(Native Method)  
        - parking to wait for  <0x0000000657459540> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)  
        at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)  
        at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2082)  
        at org.eclipse.jetty.util.BlockingArrayQueue.poll(BlockingArrayQueue.java:342)  
        at org.eclipse.jetty.util.thread.QueuedThreadPool.idleJobPoll(QueuedThreadPool.java:526)  
        at org.eclipse.jetty.util.thread.QueuedThreadPool.access$600(QueuedThreadPool.java:44)  
        at org.eclipse.jetty.util.thread.QueuedThreadPool$3.run(QueuedThreadPool.java:572)  
        at java.lang.Thread.run(Thread.java:745)  
    
    "pool-68894-thread-1" prio=10 tid=0x00007f73649a1800 nid=0x6d7 waiting on condition [0x00007f7130544000]  
       java.lang.Thread.State: TIMED_WAITING (parking)  
        at sun.misc.Unsafe.park(Native Method)  
        - parking to wait for  <0x00000006c5af6798> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)  
        at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)  
        at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2082)  
        at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:1090)  
        at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:807)  
        at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1068)  
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1130)  
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)  
        at java.lang.Thread.run(Thread.java:745)  

    各状态说明:

    New: 当线程对象创建时存在的状态,此时线程不可能执行;

    Runnable:当调用thread.start()后,线程变成为Runnable状态。只要得到CPU,就可以执行;

    Running:线程正在执行;

    Waiting:执行thread.join()或在锁对象调用obj.wait()等情况就会进该状态,表明线程正处于等待某个资源或条件发生来唤醒自己;

    Timed_Waiting:执行Thread.sleep(long)、thread.join(long)或obj.wait(long)等就会进该状态,与Waiting的区别在于Timed_Waiting的等待有时间限制;

    Blocked:如果进入同步方法或同步代码块,没有获取到锁,则会进入该状态;

    Dead:线程执行完毕,或者抛出了未捕获的异常之后,会进入dead状态,表示该线程结束

    其次,对于jstack日志,我们要着重关注如下关键信息

    Deadlock:表示有死锁

    Waiting on
    condition:等待某个资源或条件发生来唤醒自己。具体需要结合jstacktrace来分析,比如线程正在sleep,网络读写繁忙而等待

    Blocked:阻塞

    Waiting on monitor entry:在等待获取锁

    in Object.wait():获取锁后又执行obj.wait()放弃锁

    对于Waiting on monitor entry 和 in Object.wait()的详细描述:Monitor是
    Java中用以实现线程之间的互斥与协作的主要手段,它可以看成是对象或者 Class的锁。每一个对象都有,也仅有一个
    monitor。从下图中可以看出,每个 Monitor在某个时刻,只能被一个线程拥有,该线程就是 “Active
    Thread”,而其它线程都是 “Waiting Thread”,分别在两个队列 ” Entry Set”和 “Wait
    Set”里面等候。在 “Entry Set”中等待的线程状态是 “Waiting for monitor entry”,而在 “Wait
    Set”中等待的线程状态是 “in Object.wait()”

    总结:
    对于jstack日志,我们要着重关注如下关键信息
    Deadlock:表示有死锁
    Waiting on condition:等待某个资源或条件发生来唤醒自己。具体需要结合jstacktrace来分析,比如线程正在sleep,网络读写繁忙而等待
    Blocked:阻塞
    Waiting on monitor entry:在等待获取锁

    来自: http://my.oschina.net/feichexia/blog/196575

    展开全文
  • jmap和jstack使用

    万次阅读 多人点赞 2017-04-17 18:15:08
    先jps -ml  再sudo -u hive /usr/java/latest/bin/jstack 19661(此为进程号) > /tmp/jstack.txt

    先jps -ml 

    再sudo -u hive /usr/java/latest/bin/jstack 19661(此为进程号) > /tmp/jstack.txt


    首先回顾下相关概念:

    Java堆和栈的区别 

    栈与堆都是Java用来在Ram中存放数据的地方
    。与C++不同,Java自动管理栈和堆,程序员不能直接地设置栈或堆。 
    Java的堆是一个运行时数据区,类的对象从中分配空间。这些对象通过new、newarray、anewarray和 multianewarray等指令建立,它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的,堆的优势是可以动态地分配内存大小,生存期也不必事先告诉编译器,因为它是在运行时动态分配内存的,Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是,由于要在运行时动态分配内存,存取速度较慢。 

    栈的优势是,存取速度比堆要快,仅次于寄存器,栈数据可以共享。但缺点是,存在栈中的数据大小与生存期必须是确定的,缺乏灵活性。 

    栈中主要存放一些基本类型的变量(,int, short, long, byte, float, double, boolean, char)和对象句柄。 
    栈有一个很重要的特殊性,就是存在栈中的数据可以共享。假设我们同时定义: 
    int a = 3; 
    int b = 3; 
    编译器先处理int a = 3;首先它会在栈中创建一个变量为a的引用,然后查找栈中是否有3这个值,如果没找到,就将3存放进来,然后将a指向3。接着处理int b = 3;在创建完b的引用变量后,因为在栈中已经有3这个值,便将b直接指向3。这样,就出现了a与b同时均指向3的情况。 
    这时,如果再令a=4;那么编译器会重新搜索栈中是否有4值,如果没有,则将4存放进来,并令a指向4;如果已经有了,则直接将a指向这个地址。因此a值的改变不会影响到b的值。 
    要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的,因为这种情况a的修改并不会影响到b, 它是由编译器完成的,它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态,会影响到另一个对象引用变量。


    A、 jps(Java Virtual Machine Process Status Tool)      

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

    jps [options] [hostid]

        如果不指定hostid就默认为当前主机或服务器。

        命令行参数选项说明如下:

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

       比如下面:

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

     

    B、 jstack

        jstack主要用来查看某个Java进程内的线程堆栈信息。语法格式如下:

    jstack [option] pid
    jstack [option] executable core
    jstack [option] [server-id@]remote-hostname-or-ip

        命令行参数选项说明如下:

    -l long listings,会打印出额外的锁信息,在发生死锁时可以用jstack -l pid来观察锁持有情况
    -m mixed mode,不仅会输出Java堆栈信息,还会输出C/C++堆栈信息(比如Native方法)

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

        第一步先找出Java进程ID,我部署在服务器上的Java应用名称为mrf-center:

    root@ubuntu:/# ps -ef | grep mrf-center | grep -v grep
    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性能调优监控工具jps、jstack、jmap、jhat、jstat使用详解

        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(),我找了下我的代码,定位到下面的代码:

    // Idle wait
    getLog().info("Thread [" + getName() + "] is idle waiting...");
    schedulerThreadState = PollTaskSchedulerThreadState.IdleWaiting;
    long now = System.currentTimeMillis();
    long waitTime = now + getIdleWaitTime();
    long timeUntilContinue = waitTime - now;
    synchronized(sigLock) {
    	try {
        	if(!halted.get()) {
        		sigLock.wait(timeUntilContinue);
        	}
        } 
    	catch (InterruptedException ignore) {
        }
    }

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

     

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

        jmap用来查看堆内存使用状况,一般结合jhat使用。

        jmap语法格式如下:

    jmap [option] pid
    jmap [option] executable core
    jmap [option] [server-id@]remote-hostname-or-ip

        如果运行在64位JVM上,可能需要指定-J-d64命令选项参数。

    jmap -permstat pid

        打印进程的类加载器和类加载器加载的持久代对象信息,输出:类加载器名称、对象是否存活(不可靠)、对象地址、父类加载器、已加载的类大小等信息,如下图:

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

       使用jmap -heap pid查看进程堆内存使用情况,包括使用的GC算法、堆配置参数和各代中堆内存使用情况。比如下面的例子:

    root@ubuntu:/# jmap -heap 21711
    Attaching to process ID 21711, please wait...
    Debugger attached successfully.
    Server compiler detected.
    JVM version is 20.10-b01
    
    using thread-local object allocation.
    Parallel GC with 4 thread(s)
    
    Heap Configuration:
       MinHeapFreeRatio = 40
       MaxHeapFreeRatio = 70
       MaxHeapSize      = 2067791872 (1972.0MB)
       NewSize          = 1310720 (1.25MB)
       MaxNewSize       = 17592186044415 MB
       OldSize          = 5439488 (5.1875MB)
       NewRatio         = 2
       SurvivorRatio    = 8
       PermSize         = 21757952 (20.75MB)
       MaxPermSize      = 85983232 (82.0MB)
    
    Heap Usage:
    PS Young Generation
    Eden Space:
       capacity = 6422528 (6.125MB)
       used     = 5445552 (5.1932830810546875MB)
       free     = 976976 (0.9317169189453125MB)
       84.78829520089286% used
    From Space:
       capacity = 131072 (0.125MB)
       used     = 98304 (0.09375MB)
       free     = 32768 (0.03125MB)
       75.0% used
    To Space:
       capacity = 131072 (0.125MB)
       used     = 0 (0.0MB)
       free     = 131072 (0.125MB)
       0.0% used
    PS Old Generation
       capacity = 35258368 (33.625MB)
       used     = 4119544 (3.9287033081054688MB)
       free     = 31138824 (29.69629669189453MB)
       11.683876009235595% used
    PS Perm Generation
       capacity = 52428800 (50.0MB)
       used     = 26075168 (24.867218017578125MB)
       free     = 26353632 (25.132781982421875MB)
       49.73443603515625% used
       ....

        使用jmap -histo[:live] pid查看堆内存中的对象数目、大小统计直方图,如果带上live则只统计活对象,如下:

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

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

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

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

    jmap -dump:format=b,file=dumpFileName

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

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

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

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

         然后就可以在浏览器中输入主机地址:9998查看了:

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

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

     

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

        语法格式如下:

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

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

    root@ubuntu:/# jstat -gc 21711 250 4
     S0C    S1C    S0U    S1U      EC       EU        OC         OU       PC     PU    YGC     YGCT    FGC    FGCT     GCT   
    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
    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
    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
    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总耗时

     

    其他JVM性能调优参考资料:

    《Java虚拟机规范》

    《Java Performance》

    《Trouble Shooting Guide for JavaSE 6 with HotSpot VM》: http://www.oracle.com/technetwork/java/javase/tsg-vm-149989.pdf 

    《Effective Java》

    VisualVM: http://docs.oracle.com/javase/7/docs/technotes/guides/visualvm/

    jConsole: http://docs.oracle.com/javase/1.5.0/docs/guide/management/jconsole.html

    Monitoring and Managing JavaSE 6 Applications: http://www.oracle.com/technetwork/articles/javase/monitoring-141801.html

    来自: http://my.oschina.net/feichexia/blog/196575


    jstack信息分析

    2017-04-17 17:45:39
    Full thread dump Java HotSpot(TM) 64-Bit Server VM (24.71-b01 mixed mode):
    
    "Attach Listener" daemon prio=10 tid=0x00007f75a4001000 nid=0x947 waiting on condition [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE
    
    "LeaseRenewer:hive@nameservice1" daemon prio=10 tid=0x00007f7364f5a000 nid=0x537 waiting on condition [0x00007f713407f000]
       java.lang.Thread.State: TIMED_WAITING (sleeping)
    	at java.lang.Thread.sleep(Native Method)
    	at org.apache.hadoop.hdfs.LeaseRenewer.run(LeaseRenewer.java:438)
    	at org.apache.hadoop.hdfs.LeaseRenewer.access$700(LeaseRenewer.java:71)
    	at org.apache.hadoop.hdfs.LeaseRenewer$1.run(LeaseRenewer.java:298)
    	at java.lang.Thread.run(Thread.java:745)
    
    "HiveServer2-Handler-Pool: Thread-883126" prio=10 tid=0x00007f73bc016000 nid=0x4e5 waiting on condition [0x00007f7137bba000]
       java.lang.Thread.State: TIMED_WAITING (parking)
    	at sun.misc.Unsafe.park(Native Method)
    	- parking to wait for  <0x00000006585a35d8> (a java.util.concurrent.SynchronousQueue$TransferStack)
    	at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)
    	at java.util.concurrent.SynchronousQueue$TransferStack.awaitFulfill(SynchronousQueue.java:460)
    	at java.util.concurrent.SynchronousQueue$TransferStack.transfer(SynchronousQueue.java:359)
    	at java.util.concurrent.SynchronousQueue.poll(SynchronousQueue.java:942)
    	at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1068)
    	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1130)
    	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    	at java.lang.Thread.run(Thread.java:745)
    
    "IPC Parameter Sending Thread #729" daemon prio=10 tid=0x00007f7364f59000 nid=0x73cc waiting on condition [0x00007f712c302000]
       java.lang.Thread.State: TIMED_WAITING (parking)
    	at sun.misc.Unsafe.park(Native Method)
    	- parking to wait for  <0x0000000656680e10> (a java.util.concurrent.SynchronousQueue$TransferStack)
    	at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)
    	at java.util.concurrent.SynchronousQueue$TransferStack.awaitFulfill(SynchronousQueue.java:460)
    	at java.util.concurrent.SynchronousQueue$TransferStack.transfer(SynchronousQueue.java:359)
    	at java.util.concurrent.SynchronousQueue.poll(SynchronousQueue.java:942)
    	at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1068)
    	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1130)
    	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    	at java.lang.Thread.run(Thread.java:745)
    
    "HiveServer2-Handler-Pool: Thread-882656" prio=10 tid=0x00007f73bc013000 nid=0x497a waiting on condition [0x00007f712cc0b000]
       java.lang.Thread.State: TIMED_WAITING (parking)
    	at sun.misc.Unsafe.park(Native Method)
    	- parking to wait for  <0x00000006585a35d8> (a java.util.concurrent.SynchronousQueue$TransferStack)
    	at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)
    	at java.util.concurrent.SynchronousQueue$TransferStack.awaitFulfill(SynchronousQueue.java:460)
    	at java.util.concurrent.SynchronousQueue$TransferStack.transfer(SynchronousQueue.java:359)
    	at java.util.concurrent.SynchronousQueue.poll(SynchronousQueue.java:942)
    	at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1068)
    	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1130)
    	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    	at java.lang.Thread.run(Thread.java:745)
    
    "qtp931145444-882653" daemon prio=10 tid=0x00007f747401c000 nid=0x3376 waiting on condition [0x00007f7137dbc000]
       java.lang.Thread.State: TIMED_WAITING (parking)
    	at sun.misc.Unsafe.park(Native Method)
    	- parking to wait for  <0x0000000657459540> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
    	at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)
    	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2082)
    	at org.eclipse.jetty.util.BlockingArrayQueue.poll(BlockingArrayQueue.java:342)
    	at org.eclipse.jetty.util.thread.QueuedThreadPool.idleJobPoll(QueuedThreadPool.java:526)
    	at org.eclipse.jetty.util.thread.QueuedThreadPool.access$600(QueuedThreadPool.java:44)
    	at org.eclipse.jetty.util.thread.QueuedThreadPool$3.run(QueuedThreadPool.java:572)
    	at java.lang.Thread.run(Thread.java:745)
    
    "qtp931145444-882456" daemon prio=10 tid=0x00007f7470001000 nid=0x9600 waiting on condition [0x00007f7133776000]
       java.lang.Thread.State: TIMED_WAITING (parking)
    	at sun.misc.Unsafe.park(Native Method)
    	- parking to wait for  <0x0000000657459540> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
    	at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)
    	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2082)
    	at org.eclipse.jetty.util.BlockingArrayQueue.poll(BlockingArrayQueue.java:342)
    	at org.eclipse.jetty.util.thread.QueuedThreadPool.idleJobPoll(QueuedThreadPool.java:526)
    	at org.eclipse.jetty.util.thread.QueuedThreadPool.access$600(QueuedThreadPool.java:44)
    	at org.eclipse.jetty.util.thread.QueuedThreadPool$3.run(QueuedThreadPool.java:572)
    	at java.lang.Thread.run(Thread.java:745)
    
    "qtp931145444-882454" daemon prio=10 tid=0x00007f7454005800 nid=0x8ca1 waiting on condition [0x00007f713508f000]
       java.lang.Thread.State: TIMED_WAITING (parking)
    	at sun.misc.Unsafe.park(Native Method)
    	- parking to wait for  <0x0000000657459540> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
    	at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)
    	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2082)
    	at org.eclipse.jetty.util.BlockingArrayQueue.poll(BlockingArrayQueue.java:342)
    	at org.eclipse.jetty.util.thread.QueuedThreadPool.idleJobPoll(QueuedThreadPool.java:526)
    	at org.eclipse.jetty.util.thread.QueuedThreadPool.access$600(QueuedThreadPool.java:44)
    	at org.eclipse.jetty.util.thread.QueuedThreadPool$3.run(QueuedThreadPool.java:572)
    	at java.lang.Thread.run(Thread.java:745)
    
    "qtp931145444-881328" daemon prio=10 tid=0x00007f746c001800 nid=0x184c waiting on condition [0x00007f713306f000]
       java.lang.Thread.State: TIMED_WAITING (parking)
    	at sun.misc.Unsafe.park(Native Method)
    	- parking to wait for  <0x0000000657459540> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
    	at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)
    	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2082)
    	at org.eclipse.jetty.util.BlockingArrayQueue.poll(BlockingArrayQueue.java:342)
    	at org.eclipse.jetty.util.thread.QueuedThreadPool.idleJobPoll(QueuedThreadPool.java:526)
    	at org.eclipse.jetty.util.thread.QueuedThreadPool.access$600(QueuedThreadPool.java:44)
    	at org.eclipse.jetty.util.thread.QueuedThreadPool$3.run(QueuedThreadPool.java:572)
    	at java.lang.Thread.run(Thread.java:745)
    
    "pool-68894-thread-1" prio=10 tid=0x00007f73649a1800 nid=0x6d7 waiting on condition [0x00007f7130544000]
       java.lang.Thread.State: TIMED_WAITING (parking)
    	at sun.misc.Unsafe.park(Native Method)
    	- parking to wait for  <0x00000006c5af6798> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
    	at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:226)
    	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2082)
    	at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:1090)
    	at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:807)
    	at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1068)
    	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1130)
    	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    	at java.lang.Thread.run(Thread.java:745)
    

    各状态说明:
    New : 当线程对象创建时存在的状态,此时线程不可能执行;
    Runnable :当调用thread.start()后,线程变成为Runnable状态。只要得到CPU,就可以执行;
    Running :线程正在执行;
    Waiting :执行thread.join()或在锁对象调用obj.wait()等情况就会进该状态,表明线程正处于等待某个资源或条件发生来唤醒自己;
    Timed_Waiting :执行Thread.sleep(long)、thread.join(long)或obj.wait(long)等就会进该状态,与Waiting的区别在于Timed_Waiting的等待有时间限制;
    Blocked 如果进入同步方法或同步代码块,没有获取到锁,则会进入该状态
    Dead :线程执行完毕,或者抛出了未捕获的异常之后,会进入dead状态,表示该线程结束
    其次,对于jstack日志,我们要着重关注如下关键信息
    Deadlock :表示有死锁
    Waiting on condition 等待某个资源或条件发生来唤醒自 己。具体需要结合jstacktrace来分析,比如线程正在sleep,网络读写繁忙而等待
    Blocked :阻塞
    Waiting on monitor entry :在 等待获取锁
    in Object.wait() :获取锁后又执行obj.wait()放弃锁
    对于 Waiting on monitor entry     in Object.wait()的详细描述 :Monitor是 Java中用以实现线程之间的互斥与协作的主要手段,它可以看成是对象或者 Class的锁。每一个对象都有,也仅有一个 monitor。从下图中可以看出,每个 Monitor在某个时刻,只能被一个线程拥有,该线程就是 "Active Thread",而其它线程都是 "Waiting Thread",分别在两个队列 " Entry Set"和 "Wait Set"里面等候。在 "Entry Set"中等待的线程状态是 "Waiting for monitor entry",而在 "Wait Set"中等待的线程状态是 "in Object.wait()"



    总结

    对于jstack日志,我们要着重关注如下关键信息
    Deadlock :表示有死锁
    Waiting on condition :等待某个资源或条件发生来唤醒自己。具体需要结合jstacktrace来分析,比如线程正在sleep,网络读写繁忙而等待
    Blocked :阻塞
    Waiting on monitor entry :在等待获取锁

    如果说系统慢,那么要特别关注 Blocked,Waiting on condition
    如果说系统的cpu耗的高,那么肯定是线程执行有死循环,那么此时要关注下Runable状态。
    http://blog.csdn.net/zxh87/article/details/52137335


    展开全文
  • JDK本身提供了很多方便的JVM性能调优监控工具,除了集成式的VisualVMjConsole外,还有jps、jstackjmap、jhat、jstat等小巧的工具,本博客希望能起抛砖引玉之用,让大家能开始对JVM性能调优的常用工具有所了解。...

    JDK本身提供了很多方便的JVM性能调优监控工具,除了集成式的VisualVM和jConsole外,还有jps、jstack、jmap、jhat、jstat等小巧的工具,本博客希望能起抛砖引玉之用,让大家能开始对JVM性能调优的常用工具有所了解。

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

    • OutOfMemoryError,内存不足

    • 内存泄露

    • 线程死锁

    • 锁争用(Lock Contention)

    • Java进程消耗CPU过高

    • ……

    这些问题在日常开发中可能被很多人忽视(比如有的人遇到上面的问题只是重启服务器或者调大内存,而不会深究问题根源),但能够理解并解决这些问题是Java程序员进阶的必备要求。本文将对一些常用的JVM性能调优监控工具进行介绍,希望能起抛砖引玉之用。本文参考了网上很多资料,难以一一列举,在此对这些资料的作者表示感谢!关于JVM性能调优相关的资料,请参考文末。

    jps(Java Virtual Machine Process Status Tool)

    jps主要用来输出JVM进程状态信息。语法格式如下:

    jps [options] [hostid]
    • 1

    如果不指定hostid就默认为当前主机或服务器。

    命令行参数选项说明如下:

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

    比如下面:

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

    jmap

    Jmap是一个可以输出所有内存中对象的工具,甚至可以将VM 中的heap,以二进制输出成文本。打印出某个java进程(使用pid)内存内的,所有‘对象’的情况(如:产生那些对象,及其数量)。

    使用方法 jmap -histo pid。如果使用SHELL ,可采用jmap -histo pid>a.log日志将其保存到文件中,在一段时间后,使用文本对比工具,可以对比出GC回收了哪些对象。jmap -dump:format=b,file=outfile 3024 可以将3024进程的内存heap输出出来到outfile文件里,再配合MAT(内存分析工具)。

    64位机上使用需要使用如下方式:

    jmap -J-d64 -heap pid

    2、命令格式

    l jmap [ option ] pid

    l jmap [ option ] executable core

    l jmap [ option ] [server-id@]remote-hostname-or-IP

    3、参数说明

    1)、options:

    l executable :产生core dump的java可执行程序;

    l core 将被打印信息的core dump文件;

    l remote-hostname-or-IP 远程debug服务的主机名或ip;

    l server-id 唯一id,假如一台主机上多个远程debug服务;

    2)、基本参数:

    Ø -dump:[live,]format=b,file= 使用hprof二进制形式,输出jvm的heap内容到文件=. live子选项是可选的,假如指定live选项,那么只输出活的对象到文件.

    $jmap–dump:live,format=b,file=aaa.bin 3772

    持久代

    jmap -permstat pid
    

    打印进程的类加载器和类加载器加载的持久代对象信息,输出:类加载器名称、对象是否存活(不可靠)、对象地址、父类加载器、已加载的类大小等信息,如下图:

    这里写图片描述

    使用jmap -heap pid查看进程堆内存使用情况,包括使用的GC算法、堆配置参数和各代中堆内存使用情况。比如下面的例子:

    root@ubuntu:/# jmap -heap 21711
    Attaching to process ID 21711, please wait...
    Debugger attached successfully.
    Server compiler detected.
    JVM version is 20.10-b01
    
    using thread-local object allocation.
    Parallel GC with 4 thread(s)
    Heap Configuration:
       MinHeapFreeRatio = 40
       MaxHeapFreeRatio = 70
       MaxHeapSize      = 2067791872 (1972.0MB)
       NewSize          = 1310720 (1.25MB)
       MaxNewSize       = 17592186044415 MB
       OldSize          = 5439488 (5.1875MB)
       NewRatio         = 2
       SurvivorRatio    = 8
       PermSize         = 21757952 (20.75MB)
       MaxPermSize      = 85983232 (82.0MB)
    Heap Usage:
    PS Young Generation
    Eden Space:
       capacity = 6422528 (6.125MB)
       used     = 5445552 (5.1932830810546875MB)
       free     = 976976 (0.9317169189453125MB)
       84.78829520089286% used
    From Space:
       capacity = 131072 (0.125MB)
       used     = 98304 (0.09375MB)
       free     = 32768 (0.03125MB)
       75.0% used
    To Space:
       capacity = 131072 (0.125MB)
       used     = 0 (0.0MB)
       free     = 131072 (0.125MB)
       0.0% used
    PS Old Generation
       capacity = 35258368 (33.625MB)
       used     = 4119544 (3.9287033081054688MB)
       free     = 31138824 (29.69629669189453MB)
       11.683876009235595% used
    PS Perm Generation
       capacity = 52428800 (50.0MB)
       used     = 26075168 (24.867218017578125MB)
       free     = 26353632 (25.132781982421875MB)
       49.73443603515625% used
       ....
    
    •  

    直方图

    使用jmap -histo[:live] pid查看堆内存中的对象数目、大小统计直方图,如果带上live则只统计活对象,如下:

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

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

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

    分析工具

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

    jmap -dump:format=b,file=dumpFileName
    
    •  

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

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

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

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

    然后就可以在浏览器中输入主机地址:9998查看了:

    这里写图片描述

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

    jstack

    jstack主要用来查看某个Java进程内的线程堆栈信息。语法格式如下:

    jstack [option] pid
    jstack [option] executable core
    jstack [option] [server-id@]remote-hostname-or-ip
    

    命令行参数选项说明如下:

    • -l long listings,会打印出额外的锁信息,在发生死锁时可以用jstack -l pid来观察锁持有情况
    • -m mixed mode,不仅会输出Java堆栈信息,还会输出C/C++堆栈信息(比如Native方法)

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

    第一步先找出Java进程ID,我部署在服务器上的Java应用名称为mrf-center:

    root@ubuntu:/# ps -ef | grep mrf-center | grep -v grep
    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,我这里用第三个,输出如下:

    这里写图片描述

    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(),我找了下我的代码,定位到下面的代码:

    // Idle wait
    getLog().info("Thread [" + getName() + "] is idle waiting...");
    schedulerThreadState = PollTaskSchedulerThreadState.IdleWaiting;
    long now = System.currentTimeMillis();
    long waitTime = now + getIdleWaitTime();
    long timeUntilContinue = waitTime - now;
    synchronized(sigLock) {
        try {
            if(!halted.get()) {
                sigLock.wait(timeUntilContinue);
            }
        } 
        catch (InterruptedException ignore) {
        }
    }
    

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

    jstat(JVM统计监测工具)

    语法格式如下:

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

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

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

    这里写图片描述

    堆内存 = 年轻代 + 年老代 + 永久代

    年轻代 = 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总耗时
    
    •  

    其他JVM性能调优参考资料:

    《Java虚拟机规范》

    《Java Performance》

    《Trouble Shooting Guide for JavaSE 6 with HotSpot VM》: http://www.oracle.com/technetwork/java/javase/tsg-vm-149989.pdf

    《Effective Java》

    VisualVM: http://docs.oracle.com/javase/7/docs/technotes/guides/visualvm/

    jConsole: http://docs.oracle.com/javase/1.5.0/docs/guide/management/jconsole.html

    Monitoring and Managing JavaSE 6 Applications: http://www.oracle.com/technetwork/articles/javase/monitoring-141801.html

    展开全文
  • jstack和jmap工具

    千次阅读 2018-12-17 13:33:26
    jstackjmap工具jstack jstack jstack是jvm自带的跟踪堆栈信息的工具。可以输出java进程id

    jstack、jmap使用方法

    使用前提

    要配置好jdk,两个工具都是在jdk的bin目录里面的,调用时如果配置好了环境变量,那么直接在命令提示符窗口里输入命令。如果没有则手动cd到biin目录下也可以调用。输入jstack命令结果如下:
    在这里插入图片描述

    jstack

    jstack是jvm自带的跟踪堆栈信息的工具。
    在64位机器上需要加参数 “-J-d64” windows下使用只能用jstack -l pid,这里存疑,我使用了windows64位+jdk1.8并没有上述两个问题出现,貌似1.8已经不用使用这两个命令了
    主要功能有两个
    1.对现有进程做本地或远程的线程dump文件(一种包含了线程具体信息的特殊格式的文件,可以理解为快照)
    2.对core文件做线程dump(线程崩溃后使用)

    用法如下:
    1.先简单的写个测试代码
    在这里插入图片描述
    2.使用jps工具查看java线程的id(jps工具详细用法点这里
    在这里插入图片描述
    3.根据类名可知4640即为线程id,使用命令jstack 4640
    图1
    图2
    4.看第一张图中红笔标注位置可知,main线程在第8行sleep了对应代码正确
    这里线程的状态对应会有几种情况:
    new 未启动,runnable运行中,blocked受阻塞(被某个锁阻塞),wating等待中(一般停留在wait(),park()等语句中),TIMED_WATING等待时间中(上面代码中就是这种情况)

    jmap

    打印所有对象的情况
    使用-heap参数
    在这里插入图片描述
    输出各个分区的内存占用情况,包括gc的情况
    使用-histo参数
    在这里插入图片描述
    输出各个对象的实例数和大小

    区别

    两个工具的区别在于jstack是用于调试线程间的关系,解决阻塞,锁等问题
    而jmap用于输出对象,适用于解决对象内存溢出等问题
    如果想要监控整体的class情况、gc情况,可以考虑使用jstat命令用法点这里

    如果文章存在问题,欢迎交流2018-12-17

    参考文献

    java命令–jstack 工具

    展开全文
  • 上去翻日志原因是内存溢出(java.lang.OutOfMemoryError: GC overhead limit exceeded)导致的,后悔的是怕影响生产业务就直接重启了,当时没有及时导出jmapjstack,所以具体因为啥原因导致的没有查出来 很悲催,...
  • jmapjstack、jstat组合使用定位jvm问题
  • Java 监控、分析、管理工具(包括 jps、jmapjstack、jstat、jConsole、VisualVM) 非原创,主要整理,涉及文章太多,难以一一感谢。 jps 用于列出java进程 jps -q 只输出进程ID,而不输出类的短名称 jps-v ...
  • jmap jstat jstack

    2020-03-09 22:10:51
    查看对象创建的数量 jmap -histo 29936 jmap -histo 29936 >a.log 查看a.log文件中对象创建的数量 dump出堆内存 jmap -dump:format=b,file=...可以观察到jvm中当前所有线程的运行情况线程当前状态 jstack 208...
  • jconsole远程tomcat进程 修改tomcat/bin/catalina.sh文件,粘贴如下...真实应用场景,是写的定时shell脚本,测试人员主要运行脚本, 来定时抓取 快照(包含jstack和jmap),生成一段时间间隔的连续文件    
  • Kubernetes应用java程序无法使用jmapjstack的解决方案.docx
  • jstackjmap、jstat

    2020-08-28 18:56:35
    jstack详解
  • jmap一般mat配合使用。 一般在java开发的项目启动时候,最好加上下面命令,在内存溢出的时候可以通过日志查看信息。 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/java/dump 当然在项目运行的时候也可以...
  • JVM调试指令 JVM调试指令jps: 虚拟机进程状况工具默认查询输出本地虚拟机... Java配置信息工具输出JVM的参数输出Java系统属性jmap: Java内存映像工具jhat: 虚拟机堆转储快照分析工具jstack: Java堆栈跟踪工具 jps
  • linux下jmap,jstat和jstack使用

    万次阅读 2018-03-22 13:47:01
    刚好用到,转自...   先jps -ml  再sudo -u hive /usr/java/latest/bin/jstack 19661(此为进程号) &gt; /tmp/jstack.txt ...Java堆栈的区别 栈与堆都是Ja...
  • jmap,jstack,jconsole等一系列jdk所实现的小工具对学习JVM的内部原理现实中的性能分析都很有用处. 这是我分析其实现原理中的笔记. 示例代码如下: package com.hongl; import ...
  • jmap, jstack 用法

    2017-12-24 12:35:07
    jmap-dump:format=b,file=jmap.0822.b.dump 22781   Jstack
  • (2)堆信息:jmap -dump 输出的文件,(3)jstat查看gc情况,jstat -gc 间隔毫秒数 比如 jstat -gc 12345 5000 也就是每隔5秒打印进程12345的 gc情况一、看一下 jstackjstack -m >jvm_deadlocks.txt jstack -...
  • jmap/jstack 在Windows系统下报错的解决

    千次阅读 2016-12-01 16:32:22
    在学习JDK自带的各种分析JVM的命令行工具时,学习到使用jmap/jstack/jstat等命令以及jvisualvm图形化的工具。 jstat以及jvisualvm时还没有问题,但在使用jmap/jstack时,总是会报错(环境:Win7-x64系统,开发工具为...
  • jstackjmap 线上实战

    2020-12-12 22:20:47
    下面是线上机器的cpu使用率,可以看到从4月8日开始,随着时间cpu使用率在逐步增高,最终使用率达到100%导致线上服务不可用,后面重启了机器后恢复。 1、排查思路 简单分析下可能出问题的地方,分为5个方向: ...
  • 1. jstat这个命令对于查看Jvm的堆栈信息很有用。... jstack这个是用来查看jvm当前的thread dump的。可以看到当前Jvm里面的线程状况。这个对于查找blocked线程比较有意义3. jmap .这个是用来查看jvm当...
  • 通过top、jmapjstack命令,简单查看Java进程的线程情况

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,191
精华内容 7,276
关键字:

jmap和jstack的区别