「java堆栈分析工具」java中堆栈分别存放什么数据

admin 2023-03-20 10:16:08 489

今天给各位分享java堆栈分析工具的知识，其中也会对java中堆栈分别存放什么数据进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

1、JVM常用调试工具介绍
2、kill-3生成的线程堆栈怎么查看
3、如何查看java虚拟机堆内存的参数值
4、如何分析线程堆栈

JVM常用调试工具介绍

一、Linux ps （英文全拼：process status）命令用于显示当前进程的状态

ps aux 基本输出

ps aux 列名解释

注：优化机器资源主要从占用机器cpu和mem高的程序入手

二、Linux top命令查看正在运行的进程和系统负载信息，包括cpu负载、内存使用、各个进程所占系统资源等

基本输出

字段解释

三、Linux top -H -p pid。查看某个进程内部线程占用情况

四、jps(Java Virtual Machine Process Status Tool) 是java提供的一个显示当前所有java进程pid的命令

五、jinfo LVMID。可以用来查看 Java 进程运行的 JVM 参数

六、jstat(Java Virtual Machine statistics monitoring tool)主要利用JVM内建的指令对Java应用程序的资源和性能进行实时的命令行的监控，包括了对Heap size和垃圾回收状况的监控。可见，Jstat是轻量级的、专门针对JVM的工具，非常适用

七、jstack（Java Stack Trace Tool）主要用于生成java虚拟机当前时刻的线程快照。线程快照是当前java虚拟机内每一条线程正在执行的方法堆栈的集合，生成线程快照的主要目的是定位线程出现长时间停顿的原因，如线程间死锁、死循环、请求外部资源导致的长时间等待等。线程出现停顿的时候通过jstack来查看各个线程的调用堆栈，就可以知道没有响应的线程到底在后台做什么事情，或者等待什么资源

八、jmap命令(Java Memory Map)是其中之一。主要用于打印指定Java进程(或核心文件、远程调试服务器)的共享对象内存映射或堆内存细节

九、MAT(Memory Analysis Tools)是一个分析 Java堆数据的专业工具，用它可以定位内存泄漏的原因

此次分享准备过程中，发现JDK调试工具在Root用户下访问Yarn用户启动的Java虚拟机，获取不到信息，jstatck获取到的还不全（没有线程描述信息行）

可以使用 sudo -u yarn /usr/java/jdk1.8.0_181-cloudera/bin/jstack 这种方式获取。

kill-3生成的线程堆栈怎么查看

第一步：在终端运行Java程序

第二步：通过命令 pidof java 找到已经启动的java进程的ID，选择需要查看的java程序的进程ID

第三步：使用命令 kill -3 java进行的 pid 打印出java程序的线程堆栈信息

第四步：通常情况下运行的项目可能会比较大，那么这个时候打印的堆栈信息可能会有几千到几万行，为了方便查看，我们往往需要将输出内容进行重定向

使用linux下的重定向命令方式即可：例如： demo.sh run.log 21 将输出信息重定向到 run.log中。

注：在操作系统中，0 1 2分别对应着不同的含义，如下：

0 ：标准输入，即：C中的stdin ， java中的System.in

1 ：标准输出，即：C中的stdout ，java中的System.out

2 ：错误输出，即：C中的stderr ， java中的System.err

Demo：

----------------------------------------------------------------------------------------------

Sources Code ：

public class PrintThreadTrace {

Object obj1 = new Object();

Object obj2 = new Object();

public void func1(){

synchronized (obj1){

func2();

}

public void func2(){

synchronized (obj2){

while(true){

System.out.print("");

}

public static void main(String[] args){

PrintThreadTrace ptt = new PrintThreadTrace();

ptt.func1();

}

----------------------------------------------------------------------------------------------------------------

按照步骤操作后的打印输出信息：

Full thread dump Java HotSpot(TM) 64-Bit Server VM (24.79-b02 mixed mode):

"Service Thread" daemon prio=10 tid=0x00007fdc880a9000 nid=0x12a4 runnable [0x0000000000000000]

java.lang.Thread.State: RUNNABLE

"C2 CompilerThread1" daemon prio=10 tid=0x00007fdc880a7000 nid=0x12a3 waiting on condition [0x0000000000000000]

java.lang.Thread.State: RUNNABLE

"C2 CompilerThread0" daemon prio=10 tid=0x00007fdc880a4000 nid=0x12a2 waiting on condition [0x0000000000000000]

java.lang.Thread.State: RUNNABLE

"JDWP Command Reader" daemon prio=10 tid=0x00007fdc50001000 nid=0x1299 runnable [0x0000000000000000]

java.lang.Thread.State: RUNNABLE

"JDWP Event Helper Thread" daemon prio=10 tid=0x00007fdc880a1800 nid=0x1298 runnable [0x0000000000000000]

java.lang.Thread.State: RUNNABLE

"JDWP Transport Listener: dt_socket" daemon prio=10 tid=0x00007fdc8809e000 nid=0x1297 runnable [0x0000000000000000]

java.lang.Thread.State: RUNNABLE

"Signal Dispatcher" daemon prio=10 tid=0x00007fdc88091000 nid=0x1296 waiting on condition [0x0000000000000000]

java.lang.Thread.State: RUNNABLE

"Finalizer" daemon prio=10 tid=0x00007fdc88071800 nid=0x1295 in Object.wait() [0x00007fdc77ffe000]

java.lang.Thread.State: WAITING (on object monitor)

at java.lang.Object.wait(Native Method)

- waiting on 0x00000000ecb04858 (a java.lang.ref.ReferenceQueue$Lock)

at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)

- locked 0x00000000ecb04858 (a java.lang.ref.ReferenceQueue$Lock)

at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151)

at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:209)

"Reference Handler" daemon prio=10 tid=0x00007fdc8806f800 nid=0x1294 in Object.wait() [0x00007fdc7c10b000]

java.lang.Thread.State: WAITING (on object monitor)

at java.lang.Object.wait(Native Method)

- waiting on 0x00000000ecb04470 (a java.lang.ref.Reference$Lock)

at java.lang.Object.wait(Object.java:503)

at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:133)

- locked 0x00000000ecb04470 (a java.lang.ref.Reference$Lock)

"main" prio=10 tid=0x00007fdc8800b800 nid=0x128e runnable [0x00007fdc8fef7000]

java.lang.Thread.State: RUNNABLE

at com.wenchain.study.PrintThreadTrace.func2(PrintThreadTrace.java:20)

- locked 0x00000000ecc04b20 (a java.lang.Object)

at com.wenchain.study.PrintThreadTrace.func1(PrintThreadTrace.java:13)

- locked 0x00000000ecc04b10 (a java.lang.Object)

at com.wenchain.study.PrintThreadTrace.main(PrintThreadTrace.java:27)

"VM Thread" prio=10 tid=0x00007fdc8806b000 nid=0x1293 runnable

"GC task thread#0 (ParallelGC)" prio=10 tid=0x00007fdc88021000 nid=0x128f runnable

"GC task thread#1 (ParallelGC)" prio=10 tid=0x00007fdc88023000 nid=0x1290 runnable

"GC task thread#2 (ParallelGC)" prio=10 tid=0x00007fdc88024800 nid=0x1291 runnable

"GC task thread#3 (ParallelGC)" prio=10 tid=0x00007fdc88026800 nid=0x1292 runnable

"VM Periodic Task Thread" prio=10 tid=0x00007fdc880b3800 nid=0x12a5 waiting on condition

JNI global references: 1391

Heap

PSYoungGen total 17920K, used 1270K [0x00000000ecb00000, 0x00000000ede80000, 0x0000000100000000)

eden space 15872K, 8% used [0x00000000ecb00000,0x00000000ecc3d898,0x00000000eda80000)

from space 2048K, 0% used [0x00000000edc80000,0x00000000edc80000,0x00000000ede80000)

to space 2048K, 0% used [0x00000000eda80000,0x00000000eda80000,0x00000000edc80000)

ParOldGen total 39424K, used 0K [0x00000000c6200000, 0x00000000c8880000, 0x00000000ecb00000)

object space 39424K, 0% used [0x00000000c6200000,0x00000000c6200000,0x00000000c8880000)

PSPermGen total 21504K, used 2619K [0x00000000c1000000, 0x00000000c2500000, 0x00000000c6200000)

object space 21504K, 12% used [0x00000000c1000000,0x00000000c128edd8,0x00000000c2500000)

----------------------------------------------------------------------------------------------------------------------------

上面的信息中包含了当前JVM中所有运行的线程信息，其中在示例中我们启动的线程为main线程，其余的都是JVM自己创建的。

在打印的信息中，我们可以清楚的看见当前线程的调用上下文，可以很清楚的知道程序的运行情况。

并且我们在最后面还能看见当前虚拟机中的内存使用情况，青年世代，老年世代的信息等等...

PS: 在JDK1.5以上，我们可以通过在Java程序中调用Thread.getStackTrace()方法来进行堆栈的自动打印，使得线程堆栈的打印时机可编程控制。

文章知识点与官方知识档案匹配

Java技能树首页概览

89841 人正在系统学习中

点击阅读全文

打开CSDN，阅读体验更佳

jstack-查看Java进程的线程堆栈信息,锁定高消耗资源代码

jstack主要用来查看某个Java进程内的线程堆栈信息。语法格式如下: jstack[option]pid jstack[option]executable core jstack[option][server-id@]remote-hostname-or-ip 命令行参数选项说明如下: ...

011Java并发包018查看线程堆栈信息_执笔未来的博客

java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:1088) java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:809) java.util.concurre...

最新发布 jstack -- java堆栈常用排查指令

jstack -- java堆栈常用排查指令

继续访问

热门推荐 jstack 命令查看JAVA线程堆栈

JAVA堆栈信息实际生产中，可能由于开发以及测试未能全面覆盖的代码质量、性能问题，而引致线程挂起甚至崩溃。可能就需要查看堆栈信息来排查问题了。jps -lvmjps -lvm 用于查看当前机器上运行的java进程。C:\Users\Administratorjps -lvm 7348 -Dosgi.requiredJavaVersion=1.8 -Dosgi.instance.area.defa

继续访问

Java多线程——查看线程堆栈信息

Java多线程——查看线程堆栈信息摘要：本文主要介绍了查看线程堆栈信息的方法。使用Thread类的getAllStackTraces()方法方法定义可以看到getAllStackTraces()方法的返回值是一个Map对象，key是Thread的实例，value是一个StackTraceElement实例数组： 1 public static MapThread, S...

继续访问

java堆栈常用排查指令

java 异常排查四板斧 1、查看java 堆栈线程信息说明 jstack命令打印指定Java进程、核心文件或远程调试服务器的Java线程的Java堆栈跟踪信息。对于每个Java框架，完整的类名，方法名，字节码索引(BCI)和行号(如果有的话)被打印出来。使用-m选项，jstack命令打印程序中所有线程的Java和本机帧计数器(PC)。对于每个本机帧，当可用时，将打印离PC最近的本机符号。 c++乱码的名字不会被修改。要demangle c++名称，输出这个命令可以管道到c++filt。当

继续访问

java诊断工具-Arthas（thread命令）查看当前线程堆栈

cpu使用率与linux 命令top -H -p pid的线程CPU类似 1、支持一键展示当前最忙的前N个线程并打印堆栈 thread -n 3 没有线程ID，包含[Internal]表示为JVM内部线程，参考dashboard命令的介绍。 cpuUsage为采样间隔时间内线程的CPU使用率，与dashboard命令的数据一致。 deltaTime为采样间隔时间内线程的增量CPU时间，小于1ms时被取整显示为0ms。 time线程运行总CPU...

继续访问

java查看线程的堆栈信息

通过使用jps 命令获取需要监控的进程的pid，然后使用jstackpid 命令查看线程的堆栈信息。通过jstack命令可以获取当前进程的所有线程信息。每个线程堆中信息中，都可以查看到线程ID、线程的状态（wait、sleep、running 等状态）、是否持有锁信息等。 jstack -l pid jvm_listlocks.txt 转...

继续访问

java 查看线程堆栈信息_Java多线程——查看线程堆栈信息

java多线程——查看线程堆栈信息摘要：本文主要介绍了查看线程堆栈信息的方法。使用thread类的getallstacktraces()方法方法定义可以看到getallstacktraces()方法的返回值是一个map对象，key是thread的实例，value是一个stacktraceelement实例数组：1 public static map getallstacktraces()使用可以使...

继续访问

java线程堆栈信息分析

java堆栈信息分析

继续访问

java 查看堆栈_javap 命令查看堆栈中信息

javap命令是对.java文件进行反编译，通过这个命令可以看到堆栈中是怎么压栈和出栈的已经执行顺序，这里简单解释下javap的简单的使用，下面举个例子：题目：i++ 和++i的区别解释：简单点说这个问题都不难回答，这里就不说了，但是实际上堆栈中区别也是老大了(这里就用到了javap命令)，步骤：1.在任意一个盘下面建一个名为Test.java的文件(文件名可以随意命名)代码如下：public...

继续访问

java 查看线程堆栈信息_jstack-查看Java进程的线程堆栈信息，锁定高消耗资源代码。...

jstack主要用来查看某个Java进程内的线程堆栈信息。语法格式如下：jstack[option]pidjstack[option]executablecorejstack[option][server-id@]remote-hostname-or-ip命令行参数选项说明如下：-llonglistings，会打印出额外的锁信息，在发生死锁时可以用jstack-lpid来观察...

继续访问

java堆栈信息怎么看_线程堆栈信息怎么看？ - cs_person的个人空间 - OSCHINA - 中文开源技术交流社区...

一条线程堆栈信息大概长成下面这个样子：RMI TCP Connection(267865)-172.16.5.25" daemon prio=10 tid=0x00007fd508371000 nid=0x55ae waiting for monitor entry [0x00007fd4f8684000]java.lang.Thread.State: BLOCKED (on object m...

继续访问

线程堆栈信息怎么看？

一条线程堆栈信息大概长成下面这个样子： RMI TCP Connection(267865)-172.16.5.25" daemon prio=10 tid=0x00007fd508371000 nid=0x55ae waiting for monitor entry [0x00007fd...

继续访问

java的栈和堆

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

继续访问

查看java线程_【JAVA】Java线程堆栈信息查看

如何获得线程的堆栈信息？线上服务器cpu 100%了，该如何排查问题？1.top命令查询哪个pid进程占用cpu高(ps -ef|grep java 获取PID号)2.通过 top -Hp pid 可以查看该进程下各个线程的cpu使用情况,获取占用cpu高的线程id3.执行命令：printf "%X\n" 线程tid(用于获取占用cpu高的线程id的16进制数)4.执行命令：jstack pid ...

继续访问

kill -3 java_kill -3 PID命令获取java应用堆栈信息

一、应用场景：当linux服务器出现异常情况(响应缓慢，负载持续飙升)并且服务器没有安装对应的包而无法使用jstack等命令时，可以使用linux的kill相关命令打印堆栈信息。命令格式：kill -3 PID二、执行步骤：2.1、获取java进程的PIDps -ef|grep java结果的第二列数字就是进程对应的pid。2.2、kill -3 PID(1)如果项目通过Tomcat进行发布(普通...

继续访问

jstack 工具查看JVM堆栈信息

1|0介绍 jstack是java虚拟机自带的一种堆栈跟踪工具。jstack用于打印出给定的java进程ID或corefile或远程调试服务的Java堆栈信息，如果是在64位机器上，需要指定选项"-J-d64"，Windows的jstack使用方式只支持以下的这种方式： jstack [-l] pid 主要分为两个功能： a．针对活着的进程做本地的或远程的线程dump； b．针对core文件做线程dump。 jstack用于生成java虚拟机当前时刻的线程快照。线程快照是...

继续访问

linux查看java堆栈

1、查看JAVA进程JVM参数 jinfo -flags pid(进程号) -XX:CICompilerCount=2 最大的并行编译数 -XX:InitialHeapSize=16777216 JVM 的初始堆内存大小 -XX:MaxHeapSize=257949696 JVM 的最大堆内存大小 -XX:MaxNewSize=85983232 -XX:MinHeapDeltaBytes=196608 -XX:NewSize=5570560 -XX:OldSize=11206656 2、JVM 查看.

继续访问

Linux 如何查看一个进程的堆栈

有两种方法：第一种：pstack 进程ID第二种，使用gdb 然后attach 进程ID，然后再使用命令 thread apply all bt 两种方法都可以列出进程所有的线程的当前的调用栈。不过，使用gdb的方法，还可以查看某些信息，例如局部变量，指针等。不过，如果只看调用栈的话，pstack还是很方便的。

继续访问

JAVA获取堆栈信息

1. 通过Throwable获取 StackTraceElement[] stackTrace = new Throwable().getStackTrace(); 2. 通过Thread获取 StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();

继续访问

java 查看线程栈大小_基于 Java 线程栈的问题排查

除日志外，还有没有别的方式跟踪线上服务问题呢？或者，跟踪并排除日志里无法发现的问题？方法当然是有的，就是通过现场快照定位并发现问题。我们所说的现场，主要指这两方面：Java 线程栈。线程栈是Java线程工作的快照，可以获得当前线程在做什么；Java 内存堆。堆是JVM的内存快照，可以获取内存分配相关信息。

如何查看java虚拟机堆内存的参数值

请确保java_home/bin配置到path环境变量下，因为这些工具都在jdk的bin目录下

jps(JVM Process Status Tool)：JVM机进程状况工具

用来查看基于HotSpot JVM里面所有进程的具体状态, 包括进程ID，进程启动的路径等等。与unix上的ps类似，用来显示本地有权限的java进程，可以查看本地运行着几个java程序，并显示他们的进程号。使用jps时，不需要传递进程号做为参数。

Jps也可以显示远程系统上的JAVA进程，这需要远程服务上开启了jstat服务，以及RMI注及服务，不过常用都是对本对的JAVA进程的查看。

命令格式：jps [ options ] [ hostid ]

常用参数说明：

-m 输出传递给main方法的参数，如果是内嵌的JVM则输出为null。

-l 输出应用程序主类的完整包名，或者是应用程序JAR文件的完整路径。

-v 输出传给JVM的参数。

例如：

C:\Users\Administratorjps -lmv

1796 -Dosgi.requiredJavaVersion=1.5 -Xms40m -Xmx512m -XX:MaxPermSize=256m

7340 sun.tools.jps.Jps -lmv -Denv.class.path=.;D:\DevTools\VM\jdk1.6.0_31\\lib\dt.jar;D:\DevTools\VM\jdk1.6.0_31\\lib\tools.jar; -Dapplication.home=D:\DevTools\VM\jdk1.6.0_31 -Xms8m

其中pid为1796的是我的eclipse进程，pid为7340的是jps命令本身的进程

jinfo(Configuration Info for Java)：JVM配置信息工具

可以输出并修改运行时的java 进程的opts。用处比较简单，用于输出JAVA系统参数及命令行参数

命令格式：jinfo [ options ] [ pid ]

常用参数说明：

-flag 输出，修改，JVM命令行参数

例如：

C:\Users\Administratorjinfo 1796

将会打印出很多jvm运行时参数信息，由于比较长这里不再打印出来，可以自己试试，内容一目了然

Jstack(Stack Trace for Java)：JVM堆栈跟踪工具

jstack用于打印出给定的java进程ID或core file或远程调试服务的Java堆栈信息，如果是在64位机器上，需要指定选项"-J-d64“

命令格式：jstack [ option ] pid

常用参数说明：

-F 当’jstack [-l] pid’没有相应的时候强制打印栈信息

-l 长列表. 打印关于锁的附加信息,例如属于java.util.concurrent的ownable synchronizers列表.

-m 打印java和native c/c++框架的所有栈信息.

-h | -help打印帮助信息

例如：

C:\Users\Administratorjstack 1796

2013-05-22 11:42:38

Full thread dump Java HotSpot(TM) Client VM (20.6-b01 mixed mode):

"Worker-30" prio=6 tid=0x06514c00 nid=0x1018 in Object.wait() [0x056af000]

java.lang.Thread.State: TIMED_WAITING (on object monitor)

at java.lang.Object.wait(Native Method)

at org.eclipse.core.internal.jobs.WorkerPool.sleep(WorkerPool.java:188)

- locked 0x1ad84a90 (a org.eclipse.core.internal.jobs.WorkerPool)

at org.eclipse.core.internal.jobs.WorkerPool.startJob(WorkerPool.java:220)

at org.eclipse.core.internal.jobs.Worker.run(Worker.java:50)

......

jstat(JVM statistics Monitoriing Tool)：JVM统计信息监视工具

对Java应用程序的资源和性能进行实时的命令行的监控，包括了对Heap size和垃圾回收状况的监控

命令格式：jstat [ option pid [interval [ s | ms ] [count] ] ]

常用参数说明：

-gcutil 输出已使用空间占总空间的百分比

-gccapacity 输出堆中各个区域使用到的最大和最小空间

例如：每隔1秒监控jvm内存一次，共监控5次

C:\Users\Administratorjstat -gccapacity 1796 1s 5

NGCMN NGCMX NGC S0C S1C EC OGCMN OGCMX OGC OC PGCMN PGCMX PGC PC YGC FGC

13632.0 174720.0 40896.0 4032.0 4032.0 32832.0 27328.0 349568.0 81684.0 81684.0 12288.0 262144.0 80640.0 80640.0 42 96

13632.0 174720.0 40896.0 4032.0 4032.0 32832.0 27328.0 349568.0 81684.0 81684.0 12288.0 262144.0 80640.0 80640.0 42 97

C:\Users\Administratorjstat -gcutil 1796 1s 5

S0 S1 E O P YGC YGCT FGC FGCT GCT

0.00 0.00 0.52 53.35 99.77 42 0.513 99 38.119 38.632

一些术语的中文解释：

S0C：年轻代中第一个survivor（幸存区）的容量 (字节)

S1C：年轻代中第二个survivor（幸存区）的容量 (字节)

S0U：年轻代中第一个survivor（幸存区）目前已使用空间 (字节)

S1U：年轻代中第二个survivor（幸存区）目前已使用空间 (字节)

EC：年轻代中Eden（伊甸园）的容量 (字节)

EU：年轻代中Eden（伊甸园）目前已使用空间 (字节)

OC：Old代的容量 (字节)

OU：Old代目前已使用空间 (字节)

PC：Perm(持久代)的容量 (字节)

PU：Perm(持久代)目前已使用空间 (字节)

YGC：从应用程序启动到采样时年轻代中gc次数

YGCT：从应用程序启动到采样时年轻代中gc所用时间(s)

FGC：从应用程序启动到采样时old代(全gc)gc次数

FGCT：从应用程序启动到采样时old代(全gc)gc所用时间(s)

GCT：从应用程序启动到采样时gc用的总时间(s)

NGCMN：年轻代(young)中初始化(最小)的大小 (字节)

NGCMX：年轻代(young)的最大容量 (字节)

NGC：年轻代(young)中当前的容量 (字节)

OGCMN：old代中初始化(最小)的大小 (字节)

OGCMX：old代的最大容量 (字节)

OGC：old代当前新生成的容量 (字节)

PGCMN：perm代中初始化(最小)的大小 (字节)

PGCMX：perm代的最大容量 (字节)

PGC：perm代当前新生成的容量 (字节)

S0：年轻代中第一个survivor（幸存区）已使用的占当前容量百分比

S1：年轻代中第二个survivor（幸存区）已使用的占当前容量百分比

E：年轻代中Eden（伊甸园）已使用的占当前容量百分比

O：old代已使用的占当前容量百分比

P：perm代已使用的占当前容量百分比

S0CMX：年轻代中第一个survivor（幸存区）的最大容量 (字节)

S1CMX ：年轻代中第二个survivor（幸存区）的最大容量 (字节)

ECMX：年轻代中Eden（伊甸园）的最大容量 (字节)

DSS：当前需要survivor（幸存区）的容量 (字节)（Eden区已满）

TT：持有次数限制

MTT ：最大持有次数限制

jmap( Memory Map for Java)：JVM内存映像工具

打印出某个java进程（使用pid）内存内的所有‘对象’的情况（如：产生那些对象，及其数量）

命令格式：jmap [ option ] pid

常用参数说明：

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

-histo[:live] 打印每个class的实例数目,内存占用,类全名信息. VM的内部类名字开头会加上前缀”*”. 如果live子参数加上后,只统计活的对象数量.

-F 强迫.在pid没有相应的时候使用-dump或者-histo参数. 在这个模式下,live子参数无效.

例如：以二进制形式输入当前堆内存映像到文件data.hprof中

jmap -dump:live,format=b,file=data.hprof 1796

生成的文件可以使用jhat工具进行分析，在OOM（内存溢出）时，分析大对象，非常有用

通过使用如下参数启动JVM，也可以获取到dump文件：

-XX:+HeapDumpOnOutOfMemoryError

-XX:HeapDumpPath=./java_pidpid.hprof

在jvm发生内存溢出时生成内存映像文件

jhat(JVM Heap Analysis Tool)：JVM堆转储快照分析工具

用于对JAVA heap进行离线分析的工具，他可以对不同虚拟机中导出的heap信息文件进行分析，如LINUX上导出的文件可以拿到WINDOWS上进行分析，可以查找诸如内存方面的问题。

命令格式：jhat dumpfile(jmap生成的文件)

例如：分析jmap导出的内存映像

jhat data.hprof

执行成功后，访问即可查看内存信息，

MAT(Memory Analyzer Tool)：一个基于Eclipse的内存分析工具

官网：

update：

这是eclipse的一个插件，安装后可以打开xxx.hprof文件，进行分析，比jhat更方便使用，有些时候由于线上xxx.hprof文件过大，直接使用jhat进行初步分析了，可以的话拷贝到本地分析效果更佳。

图形化监控工具：

在JDK安装目录bin下面有两个可视化监控工具

1. JConsole(Java Monitoring and Management Console) 基于JMX的可视化管理工具。

2. VisualVM(All-in-one Java Troubleshooting Tool)随JDK发布的最强大的运行监视和故障处理程序。

推荐使用VisualVM，他有很多插件，可以更方便的监控运行时JVM

如何分析线程堆栈

JVM线程堆栈是一个给定时间的快照，它能向你提供所有被创建出来的Java线程的完整清单.

每一个被发现的Java线程都会给你如下信息:

– 线程的名称；经常被中间件厂商用来识别线程的标识，一般还会带上被分配的线程池名称以及状态 (运行，阻塞等等.)

– 线程类型优先级，例如 : daemon prio=3 ** 中间件程序一般以后台守护的形式创建他们的线程，这意味着这些线程是在后台运行的；它们会向它们的用户提供服务，例如：向你的Java EE应用程序 **

– Java线程ID，例如 : tid=0x000000011e52a800 ** 这是通过 java.lang.Thread.getId() 获得的Java线程ID，它常常用自增长的长整形 1..n** 实现

– 原生线程ID，例如 : nid=0x251c** ，之所以关键是因为原生线程ID可以让你获得诸如从操作系统的角度来看那个线程在你的JVM中使用了大部分的CPU时间等这样的相关信息. **

– Java线程状态和详细信息，例如: waiting for monitor entry [0xfffffffea5afb000] java.lang.Thread.State: BLOCKED (on object monitor)

** 可以快速的了解到线程状态极其当前阻塞的可能原因 **

– Java线程栈跟踪；这是目前为止你能从线程堆栈中找到的最重要的数据. 这也是你花费最多分析时间的地方，因为Java栈跟踪向提供了你将会在稍后的练习环节了解到的导致诸多类型的问题的根本原因，所需要的90%的信息。

– Java 堆内存分解; 从HotSpot VM 1.6版本开始，在线程堆栈的末尾处可以看到HotSpot的内存使用情况，比如说Java的堆内存(YoungGen, OldGen) PermGen 空间。这个信息对分析由于频繁GC而引起的问题时，是很有用的。你可以使用已知的线程数据或模式做一个快速的定位。

Heap

PSYoungGen total 466944K, used 178734K [0xffffffff45c00000, 0xffffffff70800000, 0xffffffff70800000)

eden space 233472K, 76% used [0xffffffff45c00000,0xffffffff50ab7c50,0xffffffff54000000)

from space 233472K, 0% used [0xffffffff62400000,0xffffffff62400000,0xffffffff70800000)

to space 233472K, 0% used [0xffffffff54000000,0xffffffff54000000,0xffffffff62400000)

PSOldGen total 1400832K, used 1400831K [0xfffffffef0400000, 0xffffffff45c00000, 0xffffffff45c00000)

object space 1400832K, 99% used [0xfffffffef0400000,0xffffffff45bfffb8,0xffffffff45c00000)

PSPermGen total 262144K, used 248475K [0xfffffffed0400000, 0xfffffffee0400000, 0xfffffffef0400000)

object space 262144K, 94% used [0xfffffffed0400000,0xfffffffedf6a6f08,0xfffffffee0400000)

线程堆栈信息大拆解

为了让大家更好的理解，给大家提供了下面的这张图，在这张图中将HotSpot VM上的线程堆栈信息和线程池做了详细的拆解，如下图所示：

上图中可以看出线程堆栈是由多个不同部分组成的。这些信息对问题分析都很重要，但对不同的问题模式的分析会使用不同的部分（问题模式会在后面的文章中做模拟和演示。）

现在通过这个分析样例，给大家详细解释一下HoteSpot上线程堆栈信息中的各个组成部分：

# Full thread dump标示符

“Full thread dump”是一个全局唯一的关键字，你可以在中间件和单机版本Java的线程堆栈信息的输出日志中找到它（比如说在UNIX下使用：kill -3 PID ）。这是线程堆栈快照的开始部分。

Full thread dump Java HotSpot(TM) 64-Bit Server VM (20.0-b11 mixed mode):

# Java EE 中间件,第三方以及自定义应用软件中的线程

这个部分是整个线程堆栈的核心部分，也是通常需要花费最多分析时间的部分。堆栈中线程的个数取决你使用的中间件，第三方库（可能会有独立线程）以及你的应用程序（如果创建自定义线程，这通常不是一个很好的实践）。

在我们的示例线程堆栈中，WebLogic是我们所使用的中间件。从Weblogic 9.2开始, 会使用一个用“’weblogic.kernel.Default (self-tuning)”唯一标识的能自行管理的线程池

"[STANDBY] ExecuteThread: '414' for queue: 'weblogic.kernel.Default (self-tuning)'" daemon prio=3 tid=0x000000010916a800 nid=0x2613 in Object.wait() [0xfffffffe9edff000]

java.lang.Thread.State: WAITING (on object monitor)

at java.lang.Object.wait(Native Method)

- waiting on 0xffffffff27d44de0 (a weblogic.work.ExecuteThread)

at java.lang.Object.wait(Object.java:485)

at weblogic.work.ExecuteThread.waitForRequest(ExecuteThread.java:160)

- locked 0xffffffff27d44de0 (a weblogic.work.ExecuteThread)

at weblogic.work.ExecuteThread.run(ExecuteThread.java:181)

# HotSpot VM 线程

这是一个有Hotspot VM管理的内部线程，用于执行内部的原生操作。一般你不用对此操太多心，除非你(通过相关的线程堆栈以及 prstat或者原生线程Id)发现很高的CPU占用率.

"VM Periodic Task Thread" prio=3 tid=0x0000000101238800 nid=0x19 waiting on condition

# HotSpot GC 线程

当使用 HotSpot 进行并行 GC (如今在使用多个物理核心的环境下很常见), 默认创建的HotSpot VM 或者每个JVM管理一个有特定标识的GC线程时. 这些GC线程可以让VM以并行的方式执行其周期性的GC清理, 这会导致GC时间的总体减少；与此同时的代价是CPU的使用时间会增加.

"GC task thread#0 (ParallelGC)" prio=3 tid=0x0000000100120000 nid=0x3 runnable

"GC task thread#1 (ParallelGC)" prio=3 tid=0x0000000100131000 nid=0x4 runnable

………………………………………………………………………………………………………………………………………………………………

这事非常关键的数据，因为当你遇到跟GC有关的问题，诸如过度GC、内存泄露等问题是，你将可以利用这些线程的原生Id值关联的操作系统或者Java线程，进而发现任何对CPI时间的高占用. 未来的文章你将会了解到如何识别并诊断这样的问题.

# JNI 全局引用计数

JNI (Java 本地接口)的全局引用就是从本地代码到由Java垃圾收集器管理的Java对象的基本的对象引用. 它的角色就是阻止对仍然在被本地代码使用，但是技术上已经不是Java代码中的“活动的”引用了的对象的垃圾收集.

同时为了侦测JNI相关的泄露而留意JNI引用也很重要. 如果你的程序直接使用了JNI，或者像监听器这样的第三方工具，就容易造成本地的内存泄露.

JNI global references: 1925

# Java 堆栈使用视图

这些数据被添加回了 JDK 1 .6 ，向你提供有关Hotspot堆栈的一个简短而快速的视图. 我发现它在当我处理带有过高CPU占用的GC相关的问题时非常有用，你可以在一个单独的快照中同时看到线程堆栈以及Java堆的信息，让你当时就可以在一个特定的Java堆内存空间中解析（或者排除）出任何的关键点. 你如在我们的示例线程堆栈中所见，Java 的堆 OldGen 超出了最大值!