1.5-JVM 命令行调优工具

转载：《JVM系列(七) - JVM线上监控工具》
官网：《Java Platform, Standard Edition Tools Reference》

jps（Java Process Status）

jps 是用于查看有权访问的 hotspot 虚拟机的进程。当未指定 hostid 时，默认查看本机 jvm 进程，否则查看指定的 hostid 机器上的 jvm 进程，此时 hostid 所指机器必须开启 jstatd 服务。

jps 可以列出 jvm 进程 lvmid，主类类名，main 函数参数, jvm 参数，jar 名称等信息。

命令格式如下：

usage: jps [-help]
       jps [-q] [-mlvV] [<hostid>]
Definitions:
    <hostid>:      <hostname>[:<port>]

参数含义如下：

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

jinfo

jinfo（JVM Configuration info）这个命令作用是实时查看和调整虚拟机运行参数。之前的 jps -v 命令只能查看到显示指定的参数，如果想要查看未显示的参数的值就要使用 jinfo 命令。

Usage:
    jinfo [option] <pid>
        (to connect to running process)
    jinfo [option] <executable <core>
        (to connect to a core file)
    jinfo [option] [server_id@]<remote server IP or hostname>
        (to connect to remote debug server)
where <option> is one of:
    -flag <name>         to print the value of the named VM flag
    -flag [+|-]<name>    to enable or disable the named VM flag
    -flag <name>=<value> to set the named VM flag to the given value
    -flags               to print VM flags
    -sysprops            to print Java system properties
    <no option>          to print both of the above
    -h | -help           to print this help message

参数含义如下：

• pid：本地 jvm 服务的进程 ID；
• executable core：打印堆栈跟踪的核心文件；
• remote server IP/hostname：远程 debug 服务的主机名或 IP 地址；
• server id：远程 debug 服务的进程 ID。

参数选项说明如下：

查看正在运行的 jvm 进程的扩展参数。

$ jinfo -flags 31983 
Attaching to process ID 31983, please wait… 
Debugger attached successfully. 
Server compiler detected. 
JVM version is 25.91-b14 
Non-default VM flags: -XX:CICompilerCount=3 -XX:InitialHeapSize=20971520 -XX:MaxHeapFreeRatio=90 -XX:MaxHeapSize=20971520 -XX:MaxNewSize=2097152 -XX:MinHeapDeltaBytes=524288 -XX:NewSize=2097152 -XX:OldSize=18874368 -XX:+PrintGC -XX:+PrintGCDetails -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:+UseFastUnorderedTimeStamps -XX:+UseParallelGC 
Command line: -Xmx20m -Xms20m -Xmn2m -javaagent:/opt/idea-IU-181.4668.68/lib/idea_rt.jar=34989:/opt/idea-IU-181.4668.68/bin -Dfile.encoding=UTF-8

jstat

jstat 是用于识别虚拟机各种运行状态信息的命令行工具。它可以显示本地或者远程虚拟机进程中的类装载、内存、垃圾收集、jit 编译等运行数据，它是线上定位 jvm 性能的首选工具。

jstat 工具提供如下的 jvm 监控功能：

• 类的加载及卸载的情况；
• 查看新生代、老生代及元空间（MetaSpace）的容量及使用情况；
• 查看新生代、老生代及元空间（MetaSpace）的垃圾回收情况，包括垃圾回收的次数，垃圾回收所占用的时间；
• 查看新生代中 Eden 区及 Survior 区中容量及分配情况 等；

命令格式如下：

Usage: jstat -help|-options
       jstat -<option> [-t] [-h<lines>] <vmid> [<interval> [<count>]]

参数含义如下:

• option：参数选项
  • -t：可以在打印的列加上 timestamp 列，用于显示系统运行的时间；
  • -h：可以在周期性数据的时候，可以在指定输出多少行以后输出一次表头；
• vmid：Virtual Machine ID（进程的 pid）。
• lines：表头与表头的间隔行数。
• interval：执行每次的间隔时间，单位为毫秒。
• count：用于指定输出记录的次数，缺省则会一直打印。

参数选项说明如下：

• class：显示类加载 ClassLoad 的相关信息；
• compiler：显示 JIT 编译的相关信息；
• gc：显示和 gc 相关的堆信息；
• gccapacity：显示各个代的容量以及使用情况；
• gcmetacapacity：显示元空间 metaspace 的大小；
• gcnew：显示新生代信息；
• gcnewcapacity：显示新生代大小和使用情况；
• gcold：显示老年代和永久代的信息；
• gcoldcapacity：显示老年代的大小；
• gcutil：显示垃圾回收信息；
• gccause：显示垃圾回收的相关信息（同 -gcutil），同时显示最后一次或当前正在发生的垃圾回收的诱因；
• printcompilation：输出 JIT 编译的方法信息；

class

显示和监视类装载、卸载数量、总空间以及耗费的时间。

$ jstat -class 8615
Loaded  Bytes     Unloaded  Bytes      Time
7271    13325.8      1      0.9        2.98

参数列表及含义如下：

compiler

显示虚拟机实时编译（JIT）的次数和耗时等信息。

$ jstat -compiler 8615
Compiled   Failed  Invalid  Time     FailedType   FailedMethod
  3886        0       0     1.29          0

参数列表及含义如下：

gc

显示垃圾回收（gc）相关的堆信息，查看 gc 的次数及时间。

$ jstat -gc 8615
 S0C      S1C    S0U    S1U      EC       EU        OC         OU       MC     MU    CCSC   CCSU   YGC     YGCT    FGC    FGCT     GCT   
20480.0 10752.0  0.0    0.0   262128.0 130750.7  165376.0   24093.7   35456.0 33931.0 4992.0 4582.0      5    0.056   2      0.075    0.131

比如下面输出的是 GC 信息，采样时间间隔 为 250ms，采样数为 4：

$ jstat -gc 8615 250 4
 S0C      S1C    S0U    S1U      EC       EU        OC         OU       MC     MU    CCSC   CCSU   YGC     YGCT    FGC    FGCT     GCT   
20480.0 10752.0  0.0    0.0   262144.0 130750.7  165376.0   24093.7   35456.0 33931.0 4992.0 4582.0      5    0.056   2      0.075    0.131
20480.0 10752.0  0.0    0.0   262872.0 130750.7  165376.0   24093.7   35456.0 33931.0 4992.0 4582.0      5    0.056   2      0.075    0.131
20480.0 10752.0  0.0    0.0   262720.0 130750.7  165376.0   24093.7   35456.0 33931.0 4992.0 4582.0      5    0.056   2      0.075    0.131
20480.0 10752.0  0.0    0.0   262446.0 130750.7  165376.0   24093.7   35456.0 33931.0 4992.0 4582.0      5    0.056   2      0.075    0.131

参数列表及含义如下：

gccapacity

显示虚拟机内存中三代年轻代（young)，老年代（old），元空间（metaspace）对象的使用和占用大小。

$ jstat -gccapacity 8615
 NGCMN     NGCMX     NGC      S0C     S1C      EC       OGCMN      OGCMX       OGC        OC         MCMN   MCMX       MC        CCSMN  CCSMX     CCSC      YGC    FGC 
 87040.0 1397760.0 372736.0 20480.0 10752.0 262144.0   175104.0  2796544.0   165376.0   165376.0      0.0 1079296.0  35456.0      0.0 1048576.0   4992.0      5     2

参数列表及含义如下：

gcmetacapacity

显示元空间（metaspace）中对象的信息及其占用量。

$ jstat -gcmetacapacity 8615
MCMN       MCMX        MC       CCSMN      CCSMX       CCSC     YGC   FGC    FGCT     GCT   
0.0      1079296.0   35456.0     0.0     1048576.0    4992.0     5     2    0.075    0.131

参数列表及含义如下：

gcnew

显示年轻代对象的相关信息，包括两个 survivor 区和一个 Eden 区。

$ jstat -gcnew 8615
 S0C      S1C      S0U    S1U TTv MTT  DSS      EC       EU       YGC     YGCT  
20480.0 10752.0    0.0    0.0  6  15 20480.0 262144.0 131406.0      5    0.056

参数列表及含义如下：

gcnewcapacity

查看年轻代对象的信息及其占用量。

$ jstat -gcnewcapacity 8615
  NGCMN      NGCMX       NGC      S0CMX     S0C     S1CMX     S1C       ECMX        EC      YGC   FGC 
 87040.0   1397760.0   372736.0  465920.0  20480.0 465920.0  10752.0  1396736.0   262144.0   5     2

参数列表及含义如下：

gcold

显示老年代对象的相关信息。

$ jstat -gcold 8615
   MC       MU      CCSC     CCSU       OC          OU       YGC    FGC    FGCT     GCT   
 35456.0  33931.0   4992.0   4582.0    165376.0     24093.7      5     2    0.075    0.131

参数列表及含义如下：

gcoldcapacity

查看老年代对象的信息及其占用量。

$ jstat -gcoldcapacity 8615
   OGCMN       OGCMX        OGC         OC        YGC   FGC    FGCT     GCT   
  175104.0   2796544.0    165376.0    165376.0     5     2    0.075    0.131

参数列表及含义如下：

gcutil

显示垃圾回收（gc）过程中的信息，包括各个内存的使用占比，垃圾回收时间和回收次数。

$ jstat -gcutil 8615
   S0     S1     E      O      M     CCS     YGC     YGCT    FGC    FGCT     GCT   
  0.00   0.00  50.13  14.57  95.70  91.79      5    0.056     2    0.075    0.131

参数列表及含义如下：

jmap

jmap（JVM Memory Map）命令用来查看堆内存使用状况，一般结合 jhat 使用，用于生成 heap dump 文件。jmap 不仅能生成 dump 文件，还可以查询 finalize 执行队列、Java 堆和元空间 metaspace 的详细信息，如当前使用率、当前使用的是哪种收集器等等。

如果不使用这个命令，还可以使用 -XX:+HeapDumpOnOutOfMemoryError 参数来让虚拟机出现 OOM 的时候，自动生成 dump 文件。

命令格式如下：

Usage:
    jmap [option] <pid>
        (to connect to running process)
    jmap [option] <executable <core>
        (to connect to a core file)
    jmap [option] [server_id@]<remote server IP or hostname>
        (to connect to remote debug server)

参数含义如下：

• pid：本地 jvm 服务的进程 ID；
• executable core：打印堆栈跟踪的核心文件；
• remote server IP/hostname：远程 debug 服务的主机名或 IP 地址；
• server id：远程 debug 服务的进程 ID。

参数选项说明如下：

注意：dump 内存快照分析基本上包含了 histo、clstats、finalizerinfo 等功能。

heap

显示堆中的摘要信息。包括堆内存的使用情况，正在使用的 GC 算法、堆配置参数和各代中堆内存使用情况。可以用此来判断内存目前的使用情况以及垃圾回收情况。

$ jmap -heap 11368
Attaching to process ID 11368, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.101-b13
using thread-local object allocation.
Parallel GC with 2 thread(s)
Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 2684354560 (2560.0MB)
   NewSize                  = 1073741824 (1024.0MB)
   MaxNewSize               = 1073741824 (1024.0MB)
   OldSize                  = 1610612736 (1536.0MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
Heap Usage:
PS Young Generation
Eden Space:
   capacity = 852492288 (813.0MB)
   used     = 420427144 (400.95056915283203MB)
   free     = 432065144 (412.04943084716797MB)
   49.31741317993014% used
From Space:
   capacity = 113770496 (108.5MB)
   used     = 2299712 (2.19317626953125MB)
   free     = 111470784 (106.30682373046875MB)
   2.021360617079493% used
To Space:
   capacity = 107479040 (102.5MB)
   used     = 0 (0.0MB)
   free     = 107479040 (102.5MB)
   0.0% used
PS Old Generation
   capacity = 1610612736 (1536.0MB)
   used     = 50883368 (48.526161193847656MB)
   free     = 1559729368 (1487.4738388061523MB)
   3.1592552860577903% used
27595 interned Strings occupying 3138384 bytes.

这里主要对 heap configuration 的参数列表说明一下：

histo

打印堆的对象统计，包括对象实例数、内存大小等等。因为在 histo:live 前会进行 full gc，如果带上 live 则只统计活对象。不加 live 的堆大小要大于加 live 堆的大小。

$ jmap -histo:live 12498
 num     #instances         #bytes  class name
----------------------------------------------
   1:         50358        7890344  [C
   2:         22887        2014056  java.lang.reflect.Method
   3:          3151        1485512  [B
   4:         49267        1182408  java.lang.String
   5:          7836         871384  java.lang.Class
   6:         24149         772768  java.util.concurrent.ConcurrentHashMap$Node
   7:         20785         482256  [Ljava.lang.Class;
   8:          8357         435248  [Ljava.lang.Object;
   9:         10035         401400  java.util.LinkedHashMap$Entry
  10:          4803         369488  [Ljava.util.HashMap$Node;
  11:         10763         344416  java.util.HashMap$Node
  12:          5205         291480  java.util.LinkedHashMap
  13:          3055         219960  java.lang.reflect.Field
  14:           120         193408  [Ljava.util.concurrent.ConcurrentHashMap$Node;
  15:         11224         179584  java.lang.Object
  16:          1988         146152  [Ljava.lang.reflect.Method;
  17:          3036         145728  org.aspectj.weaver.reflect.ShadowMatchImpl
  18:          1771         141680  java.lang.reflect.Constructor
  19:          4903         117672  org.springframework.core.MethodClassKey
  20:          3263         104416  java.lang.ref.WeakReference
  21:          2507         100280  java.lang.ref.SoftReference
  22:          2523          97600  [I
  23:          3036          97152  org.aspectj.weaver.patterns.ExposedState
  24:          2072          95280  [Ljava.lang.String;
  25:           954          91584  org.springframework.beans.GenericTypeAwarePropertyDescriptor
  26:          1633          91448  java.lang.Class$ReflectionData
  27:          3142          90520  [Z
  28:          1671          80208  java.util.HashMap
  29:          3244          77856  java.util.ArrayList
  30:          3037          72880  [Lorg.aspectj.weaver.ast.Var;
  31:          1809          72360  java.util.WeakHashMap$Entry
  32:          1967          62944  java.util.LinkedList

其中，class name 是对象类型，对象缩写类型与真实类型的对应说明如下：

dump

dump 用于导出内存转储快照。常用的方式是通过 jmap 把进程内存使用情况 dump 到文件中，再用 jhat 分析查看。jmap 进行 dump 的命令格式如下：

jmap -dump:live,format=b,file=heap.bin <pid>

参数含义如下：

通过 jmap 导出内存快照，文件命名为 dump.bin：

[root@localhost data]# jmap -dump:format=b,file=dump.bin 12498
Dumping heap to /data/dump.bin ...
Heap dump file created

导出的 dump 文件可以通过 MAT、VisualVM 和 jhat 等工具查看分析，后面会详细介绍。

jhat

jhat（JVM Heap Analysis Tool）命令通常与 jmap 搭配使用，用来分析 jmap 生成的 dump。jhat 内置了一个微型的 HTTP/HTML 服务器，生成 dump 的分析结果后，可以在浏览器中查看。

一般不用，更多是用图形化界面工具分析 dump 文件。

注意：一般不会直接在服务器上进行分析，因为使用 jhat 是一个耗时并且耗费硬件资源的过程，一般的做法是，把服务器生成的 dump 文件复制到本地或其他机器上进行分析。

命令格式如下：

Usage:  jhat [-stack <bool>] [-refs <bool>] [-port <port>] [-baseline <file>] [-debug <int>] [-version] [-h|-help] <file>
        -J<flag>          Pass <flag> directly to the runtime system. For
                              example, -J-mx512m to use a maximum heap size of 512MB
        -stack false:     Turn off tracking object allocation call stack.
        -refs false:      Turn off tracking of references to objects
        -port <port>:     Set the port for the HTTP server.  Defaults to 7000
        -exclude <file>:  Specify a file that lists data members that should
                              be excluded from the reachableFrom query.
        -baseline <file>: Specify a baseline object dump.  Objects in
                              both heap dumps with the same ID and same class will
                              be marked as not being "new".
        -debug <int>:     Set debug level.
                                0:  No debug output
                                1:  Debug hprof file parsing
                                2:  Debug hprof file parsing, no server
        -version          Report version number
        -h|-help          Print this help and exit
        <file>            The file to read

参数含义如下：

前面提到，通过 jmap dump 出来的文件可以用 MAT、VisualVM 等工具查看，这里我们用 jhat 查看：

$ jhat -port 7000 dump.dat
Reading from dump.dat...
Dump file created Sun Aug 12 12:15:02 CST 2018
Snapshot read, resolving...
Resolving 1788693 objects...
Chasing references, expect 357 dots.....................................................................................................................................................................................................................................................................................................................................................................
Eliminating duplicate references.....................................................................................................................................................................................................................................................................................................................................................................
Snapshot resolved.
Started HTTP server on port 7000
Server is ready.

打开浏览器，输入 http://localhost:7000，查看 jhat 的分析报表页面：

可以按照包名称查看项目模块中的具体对象示例：

除此之外，报表分析的最后一页，还提供了一些扩展查询：

• 显示所有的 Root 集合；
• 显示所有 class 的当前对象实例数量（包含 JVM 平台相关类）；
• 显示所有 class 的当前对象实例数量（除去 JVM 平台相关类）；
• 显示堆内存中实例对象的统计直方图（和直接使用 jmap 没有区别）；
• 显示 finalizer 虚拟机二次回收的信息摘要；
• 执行 jhat 提供的 对象查询语言（OQL）获取指定对象的实例信息；

注意：jhat 支持根据某些条件来过滤或查询堆的对象。可以在 jhat 的 html 页面中执行 OQL 语句，来查询符合条件的对象。OQL `具体的语法可以直接访问 http://localhost:7000/oqlhelp。

在具体排查时，需要结合代码，观察是否大量应该被回收的对象一直被引用，或者是否有占用内存特别大的对象无法被回收。

jstack

jstack 用于生成 java 虚拟机当前时刻的线程快照。线程快照是当前 java 虚拟机内每一条线程正在执行的方法堆栈的集合。生成线程快照的主要目的是定位线程出现长时间停顿的原因，如线程间死锁、死循环、请求外部资源导致的长时间等待等等。
线程出现停顿的时候，通过 jstack 来查看各个线程的调用堆栈，就可以知道没有响应的线程到底在后台做什么事情，或者等待什么资源。如果 java 程序崩溃生成 core 文件，jstack 工具可以通过 core 文件获取 java stack 和 native stack 的信息，从而定位程序崩溃的原因。

命令格式如下：

Usage:
    jstack [-l] <pid>
        (to connect to running process)
    jstack -F [-m] [-l] <pid>
        (to connect to a hung process)
    jstack [-m] [-l] <executable> <core>
        (to connect to a core file)
    jstack [-m] [-l] [server_id@]<remote server IP or hostname>
        (to connect to a remote debug server)

参数含义如下：

• pid：本地 jvm 服务的进程 ID；
• executable core：打印堆栈跟踪的核心文件；
• remote server IP/hostname：远程 debug 服务的主机名或 IP 地址；
• server id：远程 debug 服务的进程 ID。

参数选项说明如下：

注意：在实际运行中，往往一次 dump 的信息，还不足以确认问题。建议产生三次 dump 信息，如果每次 dump 都指向同一个问题，才能确定问题的典型性。

系统线程状态

在 dump 文件里，值得关注的线程状态有：

1. 死锁：Deadlock（重点关注）
2. 执行中：Runnable
3. 等待资源：Waiting on condition（重点关注）
4. 等待获取监视器：Waiting on monitor entry（重点关注）
5. 暂停：Suspended
6. 对象等待中：Object.wait() 或 TIMED_WAITING
7. 阻塞：Blocked（重点关注）
8. 停止：Parked

具体的含义如下所示：

Deadlock

死锁线程，一般指多个线程调用期间发生资源的相互占用，导致一直等待无法释放的情况。

Runnable

一般指该线程正在执行状态中，该线程占用了资源，正在处理某个请求。有可能正在传递 SQL 到数据库执行，有可能在对某个文件操作，有可能进行数据类型等转换。

Waiting on condition

该状态在线程等待某个条件的发生。具体是什么原因，可以结合 stacktrace来分析。线程处于这种等待状态，一旦有数据准备好读之后，线程会重新激活，读取并处理数据。
线程正处于等待资源或等待某个条件的发生，具体的原因需要结合下面堆栈信息进行分析。

• 如果堆栈信息明确是应用代码，则证明该线程正在等待资源。一般是大量读取某种资源且该资源采用了资源锁的情况下，线程进入等待状态；
• 如果发现有大量的线程都正处于这种状态，并且堆栈信息中得知正在等待网络读写，这是因为网络阻塞导致线程无法执行，很有可能是一个网络瓶颈的征兆：
  • 网络非常繁忙，几乎消耗了所有的带宽，仍然有大量数据等待网络读写；
  • 网络可能是空闲的，但由于路由或防火墙等原因，导致包无法正常到达。
• 还有一种常见的情况是该线程在 sleep，等待 sleep 的时间到了，将被唤醒。

Blocked

线程阻塞，是指当前线程执行过程中，所需要的资源长时间等待却 一直未能获取到，被容器的线程管理器标识为阻塞状态，可以理解为等待资源超时的线程。

Waiting for monitor entry 和 in Object.wait()

Monitor 是 Java 中实现线程之间的互斥与协作的主要手段，它可以看成是对象或者 Class 的锁。每一个对象都有一个 monitor。

死锁示例

下面给出一个死锁的案例，在 IntLock 中定义了两个静态的可重入锁实例，在主方法中声明了两个线程对两把锁进行资源竞争。

public class DeadLockRunner {
    public static void main(String[] args) {
        IntLock r1 = new IntLock(1);
        IntLock r2 = new IntLock(2);
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
    }
    public static class IntLock implements Runnable {
        private static ReentrantLock lock1 = new ReentrantLock();
        private static ReentrantLock lock2 = new ReentrantLock();
        private int lock;
        public IntLock(int lock) {
            this.lock = lock;
        }
        @Override
        public void run() {
            try {
                if (lock == 1) {
                    lock1.lock();
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    lock2.lock();
                } else {
                    lock2.lock();
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    lock1.lock();
                }
            } finally {
                if (lock1.isHeldByCurrentThread()) {
                    lock1.unlock();
                }
                if (lock2.isHeldByCurrentThread()) {
                    lock2.unlock();
                }
            }
        }
    }
}

dump 日志分析

启动 DeadLockRunner 的 main() 方法，使用 jps 查看阻塞的 jvm 进程的 id，然后使用 jstack 查看线程堆栈信息，可以发现两个线程相互竞争资源，出现死锁。

$ jstack -l 15584
2018-08-12 20:35:40
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.172-b11 mixed mode):
// 省略...
Found one Java-level deadlock:
=============================
"Thread-1":
  waiting for ownable synchronizer 0x000000076ad61180, (a java.util.concurrent.locks.ReentrantLock$NonfairSync),
  which is held by "Thread-0"
"Thread-0":
  waiting for ownable synchronizer 0x000000076ad611b0, (a java.util.concurrent.locks.ReentrantLock$NonfairSync),
  which is held by "Thread-1"
Java stack information for the threads listed above:
===================================================
"Thread-1":
    at sun.misc.Unsafe.park(Native Method)
    - parking to wait for  <0x000000076ad61180> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
    at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:870)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1199)
    at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:209)
    at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
    at io.ostenant.deadlock.DeadLockRunner$IntLock.run(DeadLockRunner.java:47)
    at java.lang.Thread.run(Thread.java:748)
"Thread-0":
    at sun.misc.Unsafe.park(Native Method)
    - parking to wait for  <0x000000076ad611b0> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
    at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:870)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1199)
    at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:209)
    at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
    at io.ostenant.deadlock.DeadLockRunner$IntLock.run(DeadLockRunner.java:37)
    at java.lang.Thread.run(Thread.java:748)
Found 1 deadlock.

作者：殷建卫 链接：https://www.yuque.com/yinjianwei/vyrvkf/ugtgq0 来源：殷建卫 - 架构笔记 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。