基于JDK命令行工具的监控

JVM的参数类型

JVM参数类型大体分为三种：

  • 标准参数，基本每个版本的JVM都有的参数，比较稳定不变
  • X参数，非标准化的参数，每个JVM版本的都有些不一样，但是变化较小
  • XX参数，非标准化的参数，相对不稳定，每个JVM版本的变化都比较大，主要用于JVM调优和Debug

常见的标准参数：

  • -help
  • -server
  • -client
  • -version
  • -showversion
  • -cp
  • -classpath

常见的X参数：

  • -Xint : 解释执行
  • -Xcomp : 第一次使用就编译成本地代码
  • -Xmixed : 混合模式，JVM自己来决定是否编译成本地代码，这是默认的模式

XX参数又分为两大类，一种是Boolean类型，如下：

格式 ：-XX : [ + - ] < name > 表示启用或禁用name属性
比如：
-XX:+UseConcMarkSweepGC 表示启用UseConcMarkSweepGC
-XX:+UseG1GC 表示启用UseG1GC

另一种则是key/value类型的，如下：

格式：-XX : < name > = < value > 表示name属性的值是value
比如：
-XX:MaxGCPauseMillis=500 表示MaxGCPauseMillis属性的值是500
-XX:GCTimeRatio=19 表示GCTimeRatio属性的值是19

要说最常见的JVM参数应该是 -Xmx 与 -Xms 这两个参数，前者用于指定初始化堆的大小，而后者用于指定堆的最大值。然后就是-Xss参数，它用于指定线程的堆栈大小。可以看到这三个参数都是以-X开头的，它们是-X参数吗？实际上不是的，它们是XX参数，是属于一种缩写形式：

-Xms 等价于 -XX:InitialHeapSize
-Xmx 等价于 -XX:MaxHeapSize
-Xss 等价于 -XX:ThreadStackSize

查看JVM运行时参数

查看JVM运行时的参数是很重要的，因为只有知道当前运行的参数值，才知道要如何去调优。我这里的服务器跑了一个Tomcat，我们就以这个Tomcat进程来作为一个例子，该进程的pid是1200，如下：

常用的查看JVM运行时参数：

  • -XX:+PrintFlagsInitial 查看初始值
  • -XX:+PrintFlagsFinal 查看最终值
  • -XX:+UnlocakExperimentalVMOptions 解锁实验参数
  • -XX:+UnlocakDiagnosticVMOptions 解锁诊断参数
  • -XX:+PrintCommandLineFlags 打印命令行参数

我们来看看-XX:+PrintFlagsInitial参数的使用方式，如下：

[[email protected] ~]# java -XX:+PrintFlagsFinal -version
     bool UseCodeCacheFlushing                      = true                                {product}
     bool UseCompiler                               = true                                {product}
     bool UseCompilerSafepoints                     = true                                {product}
     bool UseCompressedClassPointers               := true                                {lp64_product}
     bool UseCompressedOops                        := true                                {lp64_product}

加上-version是因为让它最后的时候输出版本信息，不然的话就会输出帮助信息了。以上这里只是截取了部分的内容，实际打印出来的内容是很多的，大约七百多行。可以看到截取的这部分的参数都是bool类型的（还有其他类型的），而且有 = 和 := 两种符号，= 表示JVM的默认值， := 表示被用户或JVM修改的值，也就是非默认值。

注：这种直接使用java命令 + 参数的方式，实际查看的是当前这条java命令的JVM运行时参数值。

我们来介绍一个命令：jps，这个命令与Linux的ps命令类似，也是查看进程的，但jps是专门查看Java进程的，使用也很简单：

  • 功能描述: jps是用于查看有权访问的hotspot虚拟机的进程. 当未指定hostid时，默认查看本机jvm进程，否者查看指定的hostid机器上的jvm进程，此时hostid所指机器必须开启jstatd服务。 jps可以列出jvm进程lvmid，主类类名，main函数参数, jvm参数，jar名称等信息。

以下简单演示一下jps命令的常见使用方式：

[[email protected] ~]# jps  // 没添加option的时候，默认列出进程编号和简单的class或jar名称
1200 Bootstrap
2847 Jps
[[email protected] ~]# jps -l  // 输出应用程序主类完整package名称或jar完整名称.
2880 sun.tools.jps.Jps
1200 org.apache.catalina.startup.Bootstrap
[[email protected] ~]# jps -q  // 仅仅显示进程编号，不显示jar,class, main参数等信息.
1200
2901
[[email protected] ~]# jps -m // 输出主函数传入的参数.-m就是在执行程序时从命令行输入的参数
1200 Bootstrap start
2911 Jps -m
[[email protected] ~]# jps -v // 列出jvm参数
1200 Bootstrap -Djava.util.logging.config.file=/home/tomcat/apache-tomcat-8.5.8/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKeySize=2048 -Djava.protocol.handler.pkgs=org.apache.catalina.webresources -Dcatalina.base=/home/tomcat/apache-tomcat-8.5.8 -Dcatalina.home=/home/tomcat/apache-tomcat-8.5.8 -Djava.io.tmpdir=/home/tomcat/apache-tomcat-8.5.8/temp
2921 Jps -Dapplication.home=/usr/java/jdk1.8.0_111 -Xms8m
[[email protected] ~]#

还需了解更多的话，可以查看官方的文档，jps命令的官方文档地址如下：

https://docs.oracle.com/javase/8/docs/technotes/tools/unix/jps.html

如果我们需要查看一个运行时的Java进程的JVM参数，就可以使用jinfo命令。jinfo是jdk自带的命令，可以用来查看正在运行的Java应用程序的扩展参数，甚至支持在运行时，修改部分参数。以下简单演示一下jinfo命令的常见使用方式：

[[email protected] ~]# jinfo -flag MaxHeapSize 1200  // 查看该java进程的最大内存
-XX:MaxHeapSize=482344960
[[email protected] ~]# jinfo -flag UseConcMarkSweepGC 1200  // 查看是否使用了UseConcMarkSweepGC垃圾回收器
-XX:-UseConcMarkSweepGC
[[email protected] ~]# jinfo -flag UseG1GC 1200  // 查看是否使用了UseG1GC垃圾回收器
-XX:-UseG1GC
[[email protected] ~]# jinfo -flag UseParallelGC 1200  // 查看是否使用了UseParallelGC 1200垃圾回收器
-XX:-UseParallelGC
[[email protected] ~]# jinfo -flag PrintGC 1200  // 查看是否使用了PrintGC
-XX:-PrintGC
[[email protected] ~]# jinfo -flag +PrintGC 1200  // 使用PrintGC，就只需要加上+号即可
[[email protected] ~]# jinfo -flag PrintGC 1200
-XX:+PrintGC
[[email protected] ~]# jinfo -flag -PrintGC 1200  // 不使用PrintGC ，就只需要加上-号即可
[[email protected] ~]# jinfo -flags 1200  // 查看手动赋过值的JVM参数
Attaching to process ID 1200, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.111-b14
Non-default VM flags: -XX:CICompilerCount=2 -XX:InitialHeapSize=31457280 -XX:MaxHeapSize=482344960 -XX:MaxNewSize=160759808 -XX:MinHeapDeltaBytes=196608 -XX:NewSize=10485760 -XX:OldSize=20971520 -XX:+UseCompressedClassPointers -XX:+UseCompressedOops
Command line:  -Djava.util.logging.config.file=/home/tomcat/apache-tomcat-8.5.8/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKeySize=2048 -Djava.protocol.handler.pkgs=org.apache.catalina.webresources -Dcatalina.base=/home/tomcat/apache-tomcat-8.5.8 -Dcatalina.home=/home/tomcat/apache-tomcat-8.5.8 -Djava.io.tmpdir=/home/tomcat/apache-tomcat-8.5.8/temp
[[email protected] ~]#

还需了解更多的话，可以查看官方的文档，jinfo命令的官方文档地址如下：

https://docs.oracle.com/javase/8/docs/technotes/tools/unix/jinfo.html#BCGEBFDD

jstat查看JVM统计信息

Jstat 用于监控基于HotSpot的JVM，对其堆的使用情况进行实时的命令行的统计，使用jstat我们可以对指定的JVM做如下监控：

  • 类的加载及卸载情况
  • 查看垃圾回收时的信息
  • 查看新生代、老生代及持久代的容量及使用情况
  • 查看新生代、老生代及持久代的垃圾收集情况，包括垃圾回收的次数及垃圾回收所占用的时间
  • 查看新生代中Eden区及Survior区中容量及分配情况等
  • 查看JIT编译的信息

官方文档地址如下：

https://docs.oracle.com/javase/8/docs/technotes/tools/unix/jstat.html#BEHHGFAE

查看类的加载及卸载情况的相关选项：

Option Displays
-class 类加载的行为统计

-class 类加载的行为统计，命令示例：

[[email protected] ~]# jstat -class 1200 1000 3
Loaded  Bytes  Unloaded  Bytes     Time
  3249  6451.6        0     0.0       2.40
  3249  6451.6        0     0.0       2.40
  3249  6451.6        0     0.0       2.40
[[email protected] ~]#

命令说明：

  • -class 表示查看类的加载及卸载情况
  • 1200 指定进程的id
  • 1000 指定多少毫秒查看一次
  • 3 指定查看多少次，也就是输出多少行信息

打印的信息说明：

  • Loaded 已加载的类的个数
  • Bytes 已加载的类所占用的空间大小
  • Unloaded 已卸载的类的个数
  • Bytes 已卸载的类所占用的空间大小
  • Time 执行类装载和卸载操作所花费的时间

查看垃圾回收信息的相关选项：

Option Displays
-gc 垃圾回收堆的行为统计
-gcutil 垃圾回收统计概述（百分比）
-gccause 垃圾收集统计概述（同-gcutil）
-gcnew 新生代行为统计
-gcold 老年代和Metaspace区行为统计
-gccapacity 各个垃圾回收代容量(young,old,perm)和他们相应的空间统计
-gcnewcapacity 新生代与其相应的内存空间的统计
-gcoldcapacity 年老代行为统计
-gcmetacapacity Metaspace区大小统计

-gc 垃圾回收堆的行为统计，命令示例：

[[email protected] ~]# jstat -gc 1200
 S0C    S1C    S0U    S1U      EC       EU        OC         OU       MC     MU    CCSC   CCSU   YGC     YGCT    FGC    FGCT     GCT
1024.0 1024.0  0.0    35.2   8192.0   4826.9   20480.0    17994.0   20864.0 20268.3 2432.0 2238.1     29    0.134   0      0.000    0.134
[[email protected] ~]#

打印的信息说明，C即 Capacity 总容量，U即 Used 已使用的容量：

  • S0C : survivor0区的总容量
  • S1C : survivor1区的总容量
  • S0U : survivor0区已使用的容量
  • S1C : survivor1区已使用的容量
  • EC : Eden区的总容量
  • EU : Eden区已使用的容量
  • OC : Old区的总容量
  • OU : Old区已使用的容量
  • MC : 当前Metaspace区的总容量 (KB)
  • MU : Metaspace区的使用量 (KB)
  • CCSC : 压缩类空间总量
  • CCSU : 压缩类空间使用量
  • YGC : 新生代垃圾回收次数
  • YGCT : 新生代垃圾回收时间
  • FGC : 老年代垃圾回收次数
  • FGCT : 老年代垃圾回收时间
  • GCT : 垃圾回收总消耗时间

注：我这里使用的是JDK1.8版本的，如果是其他版本的JDK在这一块打印的信息会有些不一样

JVM大致的内存结构图（JDK1.8版本）：

-gccapacity 各个垃圾回收代容量(young,old,perm)和他们相应的空间统计。(同-gc，还会输出Java堆各区域使用到的最大、最小空间)，命令示例：

[[email protected] ~]# jstat -gccapacity 1200
 NGCMN    NGCMX     NGC     S0C   S1C       EC      OGCMN      OGCMX       OGC         OC       MCMN     MCMX      MC     CCSMN    CCSMX     CCSC    YGC    FGC
 10240.0 156992.0  10240.0 1024.0 1024.0   8192.0    20480.0   314048.0    20480.0    20480.0      0.0 1067008.0  20864.0      0.0 1048576.0   2432.0     29     0
[[email protected] ~]#

打印的信息说明：

  • NGCMN : 新生代占用的最小空间
  • NGCMX : 新生代占用的最大空间
  • OGCMN : 老年代占用的最小空间
  • OGCMX : 老年代占用的最大空间
  • OGC：当前年老代的容量 (KB)
  • OC：当前年老代的空间 (KB)
  • MCMN : Metaspace占用的最小空间
  • MCMX : Metaspace占用的最大空间

-gcutil 垃圾回收统计概述（同-gc，输出的是已使用空间占总空间的百分比）。命令示例：

[[email protected] ~]# jstat -gcutil 1200
  S0     S1     E      O      M     CCS    YGC     YGCT    FGC    FGCT     GCT
  0.00   3.44  90.53  87.86  97.14  92.03     29    0.134     0    0.000    0.134
[[email protected] ~]#

-gccause 垃圾收集统计概述（垃圾收集统计概述（同-gcutil），附加最近两次垃圾回收事件的原因）。命令示例：

[[email protected] ~]# jstat -gccause 1200
  S0     S1     E      O      M     CCS    YGC     YGCT    FGC    FGCT     GCT    LGCC                 GCC
  0.00   3.44  92.49  87.86  97.14  92.03     29    0.134     0    0.000    0.134 Allocation Failure   No GC
[[email protected] ~]#

打印的信息说明：

  • LGCC：最近垃圾回收的原因
  • GCC：当前垃圾回收的原因

-gcnew（统计新生代行为）。命令示例：

[[email protected] ~]# jstat -gcnew 1200
 S0C    S1C    S0U    S1U   TT MTT  DSS      EC       EU     YGC     YGCT
1024.0 1024.0    0.0   35.2 15  15  512.0   8192.0   7738.1     29    0.134
[[email protected] ~]#

打印的信息说明：

  • TT：Tenuring threshold(提升阈值)
  • MTT：最大的tenuring threshold
  • DSS：survivor区域大小 (KB)

-gcnewcapacity（新生代与其相应的内存空间的统计）。命令示例：

[[email protected] ~]# jstat -gcnewcapacity 1200
  NGCMN      NGCMX       NGC      S0CMX     S0C     S1CMX     S1C       ECMX        EC      YGC   FGC
   10240.0   156992.0    10240.0  15680.0   1024.0  15680.0   1024.0   125632.0     8192.0    29     0
[[email protected] ~]#

打印的信息说明：

  • NGC:当前年轻代的容量 (KB)
  • S0CMX:最大的S0空间 (KB)
  • S0C:当前S0空间 (KB)
  • ECMX:最大eden空间 (KB)
  • EC:当前eden空间 (KB)

-gcold（老年代和Metaspace区行为统计）。命令示例：

[[email protected] ~]# jstat -gcold 1200
   MC       MU      CCSC     CCSU       OC          OU       YGC    FGC    FGCT     GCT
 20864.0  20268.3   2432.0   2238.1     20480.0     17994.0     29     0    0.000    0.134
[[email protected] ~]#

-gcoldcapacity（老年代与其相应的内存空间的统计）。命令示例：

[[email protected] ~]# jstat -gcoldcapacity 1200
   OGCMN       OGCMX        OGC         OC       YGC   FGC    FGCT     GCT
    20480.0    314048.0     20480.0     20480.0    29     0    0.000    0.134
[[email protected] ~]#

-gcmetacapacity（Metaspace区与其相应内存空间的统计）。命令示例：

[[email protected] ~]# jstat -gcmetacapacity 1200
   MCMN       MCMX        MC       CCSMN      CCSMX       CCSC     YGC   FGC    FGCT     GCT
       0.0  1067008.0    20864.0        0.0  1048576.0     2432.0    30     0    0.000    0.136
[[email protected] ~]#

查看JIT编译信息的相关选项：

Option Displays
-compiler HotSpt JIT编译器行为统计
-printcompilation HotSpot编译方法统计

-compiler HotSpt JIT编译器行为统计，命令示例：

[[email protected] ~]# jstat -compiler 1200
Compiled Failed Invalid   Time   FailedType FailedMethod
    2332      1       0     4.80          1 org/apache/tomcat/util/IntrospectionUtils setProperty
[[email protected] ~]#

打印的信息说明：

  • Compiled : 编译数量
  • Failed : 编译失败数量
  • Invalid : 无效数量
  • Time : 编译耗时
  • FailedType : 失败类型
  • FailedMethod : 失败方法的全限定名

-printcompilation HotSpot编译方法统计，命令示例：

[[email protected] ~]# jstat -printcompilation 1200
Compiled  Size  Type Method
    2332      5    1 org/apache/tomcat/util/net/SocketWrapperBase getEndpoint
[[email protected] ~]#

打印的信息说明：

  • Compiled：被执行的编译任务的数量
  • Size：方法字节码的字节数
  • Type：编译类型
  • Method：编译方法的类名和方法名。类名使用"/" 代替 "." 作为空间分隔符. 方法名是给出类的方法名. 格式是一致于HotSpot -XX:+PrintComplation 选项

演示堆区和非堆区的内存溢出

我们都知道部署在线上的项目，是不能够直接修改其代码或随意关闭、重启服务的，所以当发生内存溢出错误时，我们需要通过监控工具去分析错误的原因。所以本小节简单演示一下JVM堆区和非堆区的内存溢出，然后我们再通过工具来分析内存溢出的原因。首先使用IDEA创建一个SpringBoot工程，工程的目录结构如下：

我这里只勾选了web和Lombok以及增加了asm依赖，因为在演示非堆区内存溢出时，我们需要通过asm来动态生成class文件。所以pom.xml文件里所配置的依赖如下：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.22</version>
    </dependency>
    <dependency>
        <groupId>asm</groupId>
        <artifactId>asm</artifactId>
        <version>3.3.1</version>
    </dependency>
</dependencies>

先来演示堆区的内存溢出，为了能够让内存更快的溢出，所以我们需要设置JVM内存参数值。如下：
1、

2、

创建一个实体类，因为对象是存放在堆区的，所以我们需要有一个实体对象来制造内存的溢出。代码如下：

package org.zero01.monitor_tuning.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
}

然后创建一个controller类，方便我们通过postman等工具去进行测试。代码如下：

package org.zero01.monitor_tuning.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.zero01.monitor_tuning.vo.User;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

/**
 * @program: monitor_tuning
 * @description: 演示内存溢出接口
 * @author: 01
 * @create: 2018-07-08 15:41
 **/
@RestController
public class MemoryController {

    // 对象的成员变量会随着对象本身而存储在堆上
    private List<User> userList = new ArrayList<>();

    /**
     * 演示堆区内存溢出接口
     * 设定jvm参数：-Xmx32M -Xms32M
     *
     * @return
     */
    @GetMapping("/heap")
    public String heap() {
        int i = 0;
        while (true) {
            // 所以不断的往成员变量里添加数据就会导致内存溢出
            userList.add(new User(i++, UUID.randomUUID().toString()));
        }
    }
}

启动SpringBoot，访问 localhost:8080/heap 后，控制台输出的错误日志如下：

演示完堆区内存溢出后，我们再来看看非堆区的内存溢出，从之前的JVM内存结构图可以看到，在JDK1.8中，非堆区就是Metaspace区。同样的为了能够让内存更快的溢出，所以我们需要设置JVM的Metaspace区参数值如下：

Metaspace区可以存储class，所以我们通过不断的存储class来制造Metaspace区的内存溢出。使用asm框架我们可以动态的创建class文件。新建一个 Metaspace 类，代码如下：

package org.zero01.monitor_tuning.loader;

import java.util.ArrayList;
import java.util.List;

import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;

/**
 * @program: monitor_tuning
 * @description: 继承ClassLoader是为了方便调用defineClass方法，因为该方法的定义为protected
 * @author: 01
 * @create: 2018-07-08 15:58
 **/
public class Metaspace extends ClassLoader {

    /**
     * 动态创建class文件
     *
     * @return
     */
    public static List<Class<?>> createClasses() {
        // 类持有
        List<Class<?>> classes = new ArrayList<Class<?>>();
        // 循环1000w次生成1000w个不同的类。
        for (int i = 0; i < 10000000; ++i) {
            ClassWriter cw = new ClassWriter(0);
            // 定义一个类名称为Class{i}，它的访问域为public，父类为java.lang.Object，不实现任何接口
            cw.visit(Opcodes.V1_1, Opcodes.ACC_PUBLIC, "Class" + i, null,
                    "java/lang/Object", null);
            // 定义构造函数<init>方法
            MethodVisitor mw = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>",
                    "()V", null, null);
            // 第一个指令为加载this
            mw.visitVarInsn(Opcodes.ALOAD, 0);
            // 第二个指令为调用父类Object的构造函数
            mw.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object",
                    "<init>", "()V");
            // 第三条指令为return
            mw.visitInsn(Opcodes.RETURN);
            mw.visitMaxs(1, 1);
            mw.visitEnd();
            Metaspace test = new Metaspace();
            byte[] code = cw.toByteArray();
            // 定义类
            Class<?> exampleClass = test.defineClass("Class" + i, code, 0, code.length);
            classes.add(exampleClass);
        }
        return classes;
    }
}

在 MemoryController 类中增加一个成员变量和一个方法，用于制造非堆区的内存溢出。代码如下：

package org.zero01.monitor_tuning.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.zero01.monitor_tuning.loader.Metaspace;
import org.zero01.monitor_tuning.vo.User;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

/**
 * @program: monitor_tuning
 * @description: 演示内存溢出接口
 * @author: 01
 * @create: 2018-07-08 15:41
 **/
@RestController
public class MemoryController {

    private List<User> userList = new ArrayList<>();
    // class会被放在Metaspace区
    private List<Class<?>> classList = new ArrayList<>();

    /**
     * 演示堆区内存溢出接口
     * 设定jvm参数：-Xmx32M -Xms32M
     *
     * @return
     */
    @GetMapping("/heap")
    public String heap() {
        int i = 0;
        while (true) {
            userList.add(new User(i++, UUID.randomUUID().toString()));
        }
    }

    /**
     * 演示非堆区内存溢出接口
     * 设定jvm参数：-XX:MetaspaceSize=32M -XX:MaxMetaspaceSize=32M
     * @return
     */
    @GetMapping("/nonheap")
    public String nonHeap() {
        int i = 0;
        while (true) {
            // 不断的存储class文件，就会导致Metaspace区内存溢出
            classList.addAll(Metaspace.createClasses());
        }
    }
}

启动SpringBoot，访问 localhost:8080/nonheap 后，控制台输出的错误日志如下：

导出内存映像文件

上一小节中，我们演示了两种内存溢出，堆区内存溢出与非堆区内存溢出。如果我们线上的项目出现这种内存溢出的错误该如何解决？我们一般主要通过分析内存映像文件，来查看是哪些类一直占用着内存没有被释放。

导出内存映像文件的几种方式：

  • 第一种：当发生内存溢出时JVM自动导出，这种方式需要设置如下两个JVM参数：
    -XX:+HeapDumpOnOutOfMemoryError
    -XX:HeapDumpPath=./
  • 第二种：使用jmap命令手动导出，我们一般都是使用这种方式，因为等到当发生内存溢出时再导出就晚了，我们应该尽量做到预防错误的发生

注：-XX:HeapDumpPath=./ 用于指定将内存映像文件导出到哪个路径

我们先演示第一种导出内存映像文件的方式，同样的，需要先设置一下JVM的参数，如下：

启动SpringBoot，访问 localhost:8080/heap 后，控制台输出的错误日志如下，可以看到内存映像文件被导出到当前工程的根目录了：

打开工程的根目录，就可以看到这个内存映像文件：

接着我们再来演示一下使用jmap命令来导出内存映像文件，命令如下：

C:\Users\admin\Desktop>jps  // 查看进程的pid
10328 Jps
1100 Launcher
12124
1308 MonitorTuningApplication
C:\Users\admin\Desktop>jmap -dump:format=b,file=heap.hprof 1308  // 导出内存映像文件
Dumping heap to C:\Users\admin\Desktop\heap.hprof ...
Heap dump file created

C:\Users\admin\Desktop>

命令选项说明：

  • -dump 导出内存映像文件
  • format 指定文件为二进制格式
  • file 指定文件的名称，默认导出到当前路径

因为当前的路径是在桌面，所以就导出到桌面上了：

如果需要了解更多关于jmap的用法，可以查阅官方文档，地址如下：

https://docs.oracle.com/javase/8/docs/technotes/tools/unix/jmap.html#CEGCECJB

使用MAT工具分析内存溢出

在上一小节中，我们已经演示了两种导出内存映像文件的方式。但是这些内存映像文件里都是些什么东西呢？我们要如何利用内存映像文件去分析问题所在呢？那这就需要用到另一个工具MAT了。

MAT是Eclipse的一个内存分析工具，全称Memory Analyzer Tools，官网地址如下：

http://www.eclipse.org/mat/

MAT的下载地址如下：

http://www.eclipse.org/mat/downloads.php

下载并解压之后，点击MemoryAnalyzer.exe即可打开该工具，并不需要打开Eclipse，虽然下载的压缩包里包含了Eclipse：

正常打开后界面如下：

然后我们打开之前演示的发生内存溢出时，JVM自动导出的内存映像文件：


内存映像文件打开后，MAT会自动分析出一个饼状图，把可能出现问题的三个地方列了出来，并通过饼状图分为了三块。Problem Suspect 1表示最有可能导致问题出现的原因所在，而且也可以看到，的确是指向了我们演示内存溢出的那个 MemoryController 类。上面也描述了，该类的一个实例所占用的内存达到了55.57%：

这样我们就很轻易的找到了问题的所在，当然线上环境肯定不会这么简单。毕竟这是我们故意去制造的内存溢出，如果是实际的生产环境会更复杂一些。

所以我们还会进行更多的分析，例如查看所有类的实例对象的数量：

或者查看指定类的实例对象数量，可以看到，User这个类的实例对象有十万多个，一个类的实例对象存在十万多个，肯定是有问题的：

右键点击这个有问题的对象，查看其强引用：

从下图中，可以看到首先是Tomcat的一个TaskThread引用了MemoryController，而MemoryController里包含了一个名为userList的集合类型成员变量，该集合中存放了十万多个User实例对象，这下基本上就可以确定是这个MemoryController里userList的问题了：

除此之外还可以查看对象所占的字节数，使用方式和查看对象数量是一样的：

MAT的常用功能就先介绍到这里，一般我们使用这些常用功能就已经能够定位问题的所在了，而且这种图形化的工具也比较好上手，这里就不过多赘述了。

jstack与线程的状态

jstack可以打印JVM内部所有的线程数据，是java虚拟机自带的一种线程堆栈跟踪工具。使用jstack打印线程堆栈信息时，可以将这些信息重定向到一个文件里，这样就相当于生成了JVM当前时刻的线程快照。线程快照是当前JVM内每一条线程正在执行的方法堆栈的集合，生成线程快照的主要目的是定位线程出现长时间停顿的原因，如线程间死锁、死循环、请求外部资源导致的长时间等待等。 线程出现停顿的时候通过jstack来查看各个线程的调用堆栈，就可以知道没有响应的线程到底在后台做什么事情，或者等待什么资源。 如果java程序崩溃生成core文件，jstack工具可以用来获得core文件的java stack和native stack的信息，从而可以轻松地知道java程序是如何崩溃和在程序何处发生问题。另外，jstack工具还可以附属到正在运行的java程序中，看到当时运行的java程序的java stack和native stack的信息, 如果现在运行的java程序呈现hung的状态，jstack是非常有用的。

jstack官方文档地址如下：

https://docs.oracle.com/javase/8/docs/technotes/tools/unix/jstack.html#BABGJDIF

使用jstack打印Java程序里所有线程堆栈信息示例：

[[email protected] ~]# jps
1200 Bootstrap
4890 Jps
[[email protected] ~]# jstack 1200  // 直接加上pid即可打印该Java程序里的所有线程堆栈信息
2018-07-08 21:48:01
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.111-b14 mixed mode):

"Attach Listener" #35 daemon prio=9 os_prio=0 tid=0x00007fd944006000 nid=0xb90 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE  // 该线程的状态为RUNNABLE  

"http-nio-8080-exec-10" #34 daemon prio=5 os_prio=0 tid=0x00007fd96c31e800 nid=0x4d3 waiting on condition [0x00007fd9487ac000]
   java.lang.Thread.State: WAITING (parking)  // 该线程的状态为WAITING
    at sun.misc.Unsafe.park(Native Method)
    - parking to wait for  <0x00000000edae5bb8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
    at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2039)
    at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:442)
    at org.apache.tomcat.util.threads.TaskQueue.take(TaskQueue.java:103)
    at org.apache.tomcat.util.threads.TaskQueue.take(TaskQueue.java:31)
    at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1067)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1127)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
    at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
    at java.lang.Thread.run(Thread.java:745)
    ...

注：nid是线程的唯一标识符，是16进制的，通常用于定位某一个线程

这里只是截取了前面两条线程的信息，可以看到这些线程都有一个java.lang.Thread.State参数，该参数的值就是该线程的状态。

Java线程状态：

  • NEW 未启动的新线程
  • RUNNABLE 正在运行的线程
  • BLOCKED 阻塞状态，一般都是在等待锁资源
  • WAITING 等待状态
  • TIMED_WAITING 有时间的等待状态
  • TERMINATED 线程已退出

线程状态转换示意图：

jstack实战死循环与死锁

本小节我们使用一个例子演示死循环与死锁，然后介绍如何利用jstack分析、定位问题的所在。

在controller包中，新建一个 CpuController 类，用于演示发生死循环与死锁时CPU占用率飙高的情况。这是一个解析json的代码，并不需要注意代码的细节，只需要知道访问这个接口会导致死循环即可。代码如下：

package org.zero01.monitor_tuning.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

/**
 * @program: monitor_tuning
 * @description: 演示死循环与死锁
 * @author: 01
 * @create: 2018-07-08 22:14
 **/
@RestController
public class CpuController {

    /**
     * 演示死循环
     */
    @RequestMapping("/loop")
    public List<Long> loop() {
        String data = "{\"data\":[{\"partnerid\":]";
        return getPartneridsFromJson(data);
    }

    public static List<Long> getPartneridsFromJson(String data) {
        //{\"data\":[{\"partnerid\":982,\"count\":\"10000\",\"cityid\":\"11\"},{\"partnerid\":983,\"count\":\"10000\",\"cityid\":\"11\"},{\"partnerid\":984,\"count\":\"10000\",\"cityid\":\"11\"}]}
        //上面是正常的数据
        List<Long> list = new ArrayList<Long>(2);
        if (data == null || data.length() <= 0) {
            return list;
        }
        int datapos = data.indexOf("data");
        if (datapos < 0) {
            return list;
        }
        int leftBracket = data.indexOf("[", datapos);
        int rightBracket = data.indexOf("]", datapos);
        if (leftBracket < 0 || rightBracket < 0) {
            return list;
        }
        String partners = data.substring(leftBracket + 1, rightBracket);
        if (partners == null || partners.length() <= 0) {
            return list;
        }
        while (partners != null && partners.length() > 0) {
            int idpos = partners.indexOf("partnerid");
            if (idpos < 0) {
                break;
            }
            int colonpos = partners.indexOf(":", idpos);
            int commapos = partners.indexOf(",", idpos);
            if (colonpos < 0 || commapos < 0) {
                //partners = partners.substring(idpos+"partnerid".length());//1
                continue;
            }
            String pid = partners.substring(colonpos + 1, commapos);
            if (pid == null || pid.length() <= 0) {
                //partners = partners.substring(idpos+"partnerid".length());//2
                continue;
            }
            try {
                list.add(Long.parseLong(pid));
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
            partners = partners.substring(commapos);
        }
        return list;
    }
}

将工程使用maven进行打包，并上传到服务器中，打包命令如下：

mvn clean package -Dmaven.test.skip=true

将jar包上传到服务器中，然后使用如下命令进行启动：

[[email protected] ~]# nohup java -jar monitor_tuning-0.0.1-SNAPSHOT.jar &

接着使用浏览器开多几个标签页来访问该工程的接口，为了让CPU负载更快飚上去：

在Linux的命令行输入top命令来查看CPU负载情况，等那么一两分钟后，会发现CPU的负载就上去了，如下：

当我们服务器的CPU像这样负载很高的时候，就可以使用jstack命令去定位哪一个线程的CPU占用率最高。通过jstack命令打印线程的堆栈信息，并重定向到一个文件中：

[[email protected] ~]# jstack 4999 > loop.txt

接着使用top命令指定查看某个进程中的线程：

[[email protected] ~]# top -p 4999 -H

通过以上这个命令，可以看到该进程中占用率最高的那几个线程，我们把占用率第一的线程的pid给记录一下：

然后通过printf命令，将pid转换成16进制的nid，实际上这里的pid就是十进制的nid，如下：

[[email protected] ~]# printf "%x" 5016
1398
[[email protected] ~]#

得出nid后，使用vim命令打开loop.txt文件，通过nid来搜索该线程的数据：

如上，通过分析线程堆栈的信息，就能定位到是哪个类的哪个方法里的哪句代码出了问题，这就是如何利用jstack命令，定位问题代码。


以上演示完如何定位发生死循环的代码后，接下来就是演示一下如何使用jstack定位发生死锁的代码。首先，在CpuController类中，增加如下代码：

private Object lock1 = new Object();
private Object lock2 = new Object();

/**
 * 演示死锁
 * */
@RequestMapping("/deadlock")
public String deadlock(){
    new Thread(()->{
        synchronized(lock1) {
            try {Thread.sleep(1000);}catch(Exception e) {}
            synchronized(lock2) {
                System.out.println("Thread1 over");
            }
        }
    }) .start();
    new Thread(()->{
        synchronized(lock2) {
            try {Thread.sleep(1000);}catch(Exception e) {}
            synchronized(lock1) {
                System.out.println("Thread2 over");
            }
        }
    }) .start();
    return "deadlock";
}

增加完以上代码后，重新使用maven命令进行打包。

回到服务器上，杀掉之前启动的服务，并把旧的jar包给删除掉：

[[email protected] ~]# jps
4999 jar
5103 Jps
[[email protected] ~]# kill -9 4999  // 杀掉进程
[[email protected] ~]# rm -rf monitor_tuning-0.0.1-SNAPSHOT.jar  // 删除之前的jar包

删除掉旧的jar包后，再重新上传新打包好的jar包，然后和之前一样使用如下命令运行该jar包：

[[email protected] ~]# nohup java -jar monitor_tuning-0.0.1-SNAPSHOT.jar &

成功运行后，同样的使用浏览器进行访问，可以看到是能够正常返回数据的，这是因为发生死锁的是子线程，并不会影响主线程：

那么我们要怎么定位死锁发生的代码呢？因为这种情况下的死锁和死循环不一样，并不会导致CPU负载率的飙高。所以我们无法使用之前那种方式去定位问题代码，但jstack比较好的一点就是，会自动帮我们找出死锁。和之前一样，使用如下命令生成一个线程快照文件：

[[email protected] ~]# jps
5128 jar
5177 Jps
[[email protected] ~]# jstack 5128 > deadlock.txt
[[email protected] ~]# vim deadlock.txt

使用vim打开该文件后，直接定位到文件的末尾，就可以看到死锁的信息，jstack会自动找出死锁，并把死锁信息放在末尾。我已经使用蓝色和红色框框标出了两个线程互相等待的锁：

原文地址：http://blog.51cto.com/zero01/2138982

时间： 2024-11-05 02:15:25

基于JDK命令行工具的监控的相关文章

JDK命令行工具整理

1.javac 编译的Java程序,生成.class文件 2.javaw 跟java命令相对的,可以运行.class文件,主要用来执行图形界面的java程序运行java命令时,会出现并保持一个console窗口,程序中的信息可以通过System.out在console内输出,而运行javaw,开始时会出现console,当主程序调用之后,console就会消失: javaw 大多用来运行GUI程序 3.javah C 头文件和 Stub 文件生成器.javah 从 Java 类生成 C 头文件和

jdk命令行工具的基本使用

jps:可以列出正在运行的虚拟机进程 主要选项 样例: jstat:用于监视虚拟机各种运行状态信息的命令行工具.它可以显示本地或者远程虚拟机进程中的类装载.内存.垃圾收集.JIT编译等运行数据 命令格式:jstat -<option> [-t] [-h<lines>] <vmid> [<interval> [<count>]]命令选项 使用样例:每250ms查询一次进程pid 9968的垃圾收集情况,一共查询10次 显示百分比 jinfo:作用是

JDK命令行工具

jps命令 列出所有Java进程,输出如下: jps -q  只输出进程id jps -m 输出传递给Java进程(主函数)的参数 jps -m -l -l用于输出主函数的完整路劲 jps -m -l -v -v显示传递给JVM的参数 2.jstat命令 可以观察Java应用程序运行时信息的工具,可以查看堆信息的详细情况 jstat -<option> [-t] [-h<lines>] <vmid> [<interval> [<count>]]

jdk命令行工具：jstat与jmap

转自文章:http://blog.csdn.net/gzh0222/article/details/8538727 C:\Users\Administrator\Desktop>jstat -gcutil 21640 S0 S1 E O P YGC YGCT FGC FGCT GCT 43.33 0.00 94.55 32.10 9.34 20 0.494 0 0.000 0.494 C:\Users\Administrator\Desktop>jmap -histo 21640 >hi

JVM虚拟机性能监控与调优（JDK命令行、JConsole）

很多资料在介绍JDK命令行工具时并不是在Java8环境下,因此还在使用过时的永久区系列的参数,给一些读者造成困难. Java8使用Metaspace(元空间)代替永久区,对于64位平台,为了压缩JVM对象中的_klass指针的大小,引入了类指针压缩空间(Compressed Class Pointer Space) .关于这点,可以参考博客https://blog.csdn.net/liang0000zai/article/details/51168095. 1. JDK命令行工具 在JDK的开

JDK的命令行工具

jps:虚拟机进程状况工具 jps(JVM Process Status Tool)可以列出正在运行的虚拟机进程,并显示虚拟机执行主类(Main Class,main()函数所在的类)名称以及这些进程的本地虚拟机唯一ID(Local Virtual Machine Identifier,LVMID).虽然功能比较单一,但它是使用频率最高的JDK命令行工具,因为其他的JDK工具大多需要输入它查询到的LVMID来确定要监控的是哪一个虚拟机进程.对于本地虚拟机进程来说,LVMID与操作系统的进程ID(

监控 Linux 性能的 18 个命令行工具

对于系统和网络管理员来说每天监控和调试Linux系统的性能问题是一项繁重的工作.在IT领域作为一名Linux系统的管理员工作5年后,我逐渐认识到监控和保持系统启动并运行是多么的不容易.基于此原因,我们已编写了最常使用的18个命令行工具列表,这些工具将有助于每个Linux/Unix 系统管理员的工作.这些命令行工具可以在各种Linux系统下使用,可以用于监控和查找产生性能问题的原因.这个命令行工具列表提供了足够的工具,您可以挑选适用于您的监控场景的工具. LitStone翻译于 2个月前 3人顶

20个命令行工具监控 Linux 系统性能（转载）

1. top — Linux 系统进程监控 top 命令是性能监控程序,它可以在很多 Linux/Unix 版本下使用,并且它也是 Linux 系统管理员经常使用的监控系统性能的工具.Top 命令可以定期显示所有正在运行和实际运行并且更新到列表中,它显示出 CPU 的使用.内存的使用.交换内存.缓存大小.缓冲区大小.过程控制.用户和更多命令.它也会显示内存和 CPU 使用率过高的正在运行的进程.当我们对 Linux 系统需要去监控和采取正确的行动时,top 命令对于系统管理员是非常有用的.让我们

监控 Linux 性能的 18 个命令行工具(转)

对于系统和网络管理员来说每天监控和调试Linux系统的性能问题是一项繁重的工作.在IT领域作为一名Linux系统的管理员工作5年后,我逐渐认识到监控和保持系统启动并运行是多么的不容易.基于此原因,我们已编写了最常使用的18个命令行工具列表,这些工具将有助于每个Linux/Unix 系统管理员的工作.这些命令行工具可以在各种Linux系统下使用,可以用于监控和查找产生性能问题的原因.这个命令行工具列表提供了足够的工具,您可以挑选适用于您的监控场景的工具. 1.Top-Linux进程监控 Linux