@ -4,971 +4,6 @@
[TOC]
# JDK Tools
## jps
用于显示当前用户下的所有java进程信息：
```shell
# jps [options] [hostid]
# q:仅输出VM标识符, m: 输出main method的参数,l:输出完全的包名, v:输出jvm参数
[root@localhost ~]# jps -l
28729 sun.tools.jps.Jps
23789 cn.ms.test.DemoMain
23651 cn.ms.test.TestMain
```
## jstat
用于监视虚拟机运行时状态信息（ ） ：
**-gc**：垃圾回收统计（大小）
```shell
# 每隔2000ms输出< pid > 进程的gc情况，
[root@localhost ~]# jstat -gc < pid > 2000 2
# 每隔2s输出< pid > 进程的gc情况，
[root@localhost ~]# jstat -gc -t -h3 < pid > 2s
Timestamp S0C S1C S0U S1U ... YGC YGCT FGC FGCT GCT
1021.6 1024.0 1024.0 0.0 1024.0 ... 1 0.012 0 0.000 0.012
1023.7 1024.0 1024.0 0.0 1024.0 ... 1 0.012 0 0.000 0.012
1025.7 1024.0 1024.0 0.0 1024.0 ... 1 0.012 0 0.000 0.012
Timestamp S0C S1C S0U S1U ... YGC YGCT FGC FGCT GCT
1027.7 1024.0 1024.0 0.0 1024.0 ... 1 0.012 0 0.000 0.012
1029.7 1024.0 1024.0 0.0 1024.0 ... 1 0.012 0 0.000 0.012
# 结果说明: C即Capacity 总容量，
##########################
# S0C： （ ）
# S1C： （ ）
# S0U： （ ）
# S1U： （ ）
# EC： （ ）
# EU： （ ）
# OC：
# OU：
# PC：
# PU：
# YGC：
# YGCT：
# FGC：
# FGCT：
# GCT：
```
**-gcutil**：垃圾回收统计（百分比）
```shell
[root@localhost bin]# jstat -gcutil < pid >
S0 S1 E O M CCS YGC YGCT FGC FGCT GCT
0.00 99.80 16.21 26.18 93.34 90.74 9 0.056 2 0.045 0.102
# 结果说明
##########################
# S0： （ ）
# S1： （ ）
# E： （ ）
# O：
# P：
# YGC：
# YGCT：
# FGC：
# FGCT：
# GCT：
```
**-gccapacity**：堆内存统计
```shell
[root@localhost ~]# jstat -gccapacity < pid >
NGCMN NGCMX NGC S0C S1C EC OGCMN OGCMX OGC OC PGCMN PGCMX PGC PC YGC FGC
84480.0 1349632.0 913408.0 54272.0 51200.0 502784.0 168448.0 2699264.0 168448.0 168448.0 21504.0 83968.0 51712.0 51712.0 9 0
# 结果说明
##########################
# NGCMN：
# NGCMX：
# NGC：
# S0C： （ ）
# S1C： （ ）
# EC： （ ）
# OGCMN：
# OGCMX：
# OGC：
# OC：
# PGCMN：
# PGCMX：
# PGC：
# PC：
# YGC：
# GCT：
```
**-gccause**：垃圾收集统计概述（同-gcutil） ，
```shell
[root@localhost ~]# jstat -gccause < pid >
S0 S1 E O P YGC YGCT FGC FGCT GCT LGCC GCC
0.00 79.23 39.37 39.92 99.74 9 0.198 0 0.000 0.198 Allocation Failure No GC
# 结果说明
##########################
# LGCC：
# GCC：
```
## jstack
jstack(Java Stack Trace)主要用于打印线程的堆栈信息， ，
```shell
# dump出进程< pid > 的线程堆栈快照至/data/1.log文件中
jstack -l < pid > >/data/1.log
# 参数说明：
# -F： （ ） ，
# -m： ，
# -l： ，
```
jstack dump文件中值得关注的线程状态有：
- ** 死锁（ ）
- 执行中（ ）
- ** 等待资源（ ）
- 等待某个资源或条件发生来唤醒自己。具体需结合jstacktrace来分析， ，
- 如果大量线程在“waiting on condition”， ，
- ** 等待获取监视器（ ）
- 如果大量线程在“waiting for monitor entry”，
- 暂停（ ）
- 对象等待中（ ）
- ** 阻塞（ ）
- 停止（ ）
**注意**： ，
**场景一：
```shell
"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 monitor)
at org.apache.log4j.Category.callAppenders(Category.java:201)
- waiting to lock < 0x00000000acf4d0c0 > (a org.apache.log4j.Logger)
at org.apache.log4j.Category.forcedLog(Category.java:388)
at org.apache.log4j.Category.log(Category.java:853)
at org.apache.commons.logging.impl.Log4JLogger.warn(Log4JLogger.java:234)
at com.tuan.core.common.lang.cache.remote.SpyMemcachedClient.get(SpyMemcachedClient.java:110)
```
- 线程状态是 Blocked，
- “ waiting to lock < 0x00000000acf4d0c0 > ”指，线程在等待给这个 0x00000000acf4d0c0 地址上锁（ ： ）
- 在 dump 日志里查找字符串 0x00000000acf4d0c0， （ < 0x00000000acf4d0c0 > ），就可以顺藤摸瓜了
- “waiting for monitor entry”说明此线程通过 synchronized(obj) {……} 申请进入了临界区， ，
- 第一行里，"RMI TCP Connection(267865)-172.16.5.25"是 Thread Name 。tid指Java Thread id。nid指native线程的id。prio是线程优先级。[0x00007fd4f8684000]是线程栈起始地址。
**场景二：
1.top命令找出最高占用的进程（ ）
2.查看高负载进程下的高负载线程（ < PID > 或ps -mp < PID > -o THREAD,tid,time）
3.找出最高占用的线程并记录thread_id， （ ）
4.（ ） （ ）
5.导出进程的堆栈日志， （ ）
6.根据找到的堆栈信息关联到代码进行定位分析即可
## jmap
jmap(Java Memory Map)主要用于打印内存映射。常用命令：
`jmap -dump:live,format=b,file=xxx.hprof <pid> `
**查看JVM堆栈的使用情况**
```powershell
[root@localhost ~]# jmap -heap 7243
Attaching to process ID 27900, please wait...
Debugger attached successfully.
Client compiler detected.
JVM version is 20.45-b01
using thread-local object allocation.
Mark Sweep Compact GC
Heap Configuration: #堆内存初始化配置
MinHeapFreeRatio = 40 #-XX:MinHeapFreeRatio设置JVM堆最小空闲比率
MaxHeapFreeRatio = 70 #-XX:MaxHeapFreeRatio设置JVM堆最大空闲比率
MaxHeapSize = 100663296 (96.0MB) #-XX:MaxHeapSize=设置JVM堆的最大大小
NewSize = 1048576 (1.0MB) #-XX:NewSize=设置JVM堆的‘ ’
MaxNewSize = 4294901760 (4095.9375MB) #-XX:MaxNewSize=设置JVM堆的‘ ’
OldSize = 4194304 (4.0MB) #-XX:OldSize=设置JVM堆的‘ ’
NewRatio = 2 #-XX:NewRatio=:‘新生代’和‘老生代’的大小比率
SurvivorRatio = 8 #-XX:SurvivorRatio=设置年轻代中Eden区与Survivor区的大小比值
PermSize = 12582912 (12.0MB) #-XX:PermSize=< value > :设置JVM堆的‘ ’
MaxPermSize = 67108864 (64.0MB) #-XX:MaxPermSize=< value > :设置JVM堆的‘ ’
Heap Usage:
New Generation (Eden + 1 Survivor Space): #新生代区内存分布，包含伊甸园区+1个Survivor区
capacity = 30212096 (28.8125MB)
used = 27103784 (25.848182678222656MB)
free = 3108312 (2.9643173217773438MB)
89.71169693092462% used
Eden Space: #Eden 区内存分布
capacity = 26869760 (25.625MB)
used = 26869760 (25.625MB)
free = 0 (0.0MB)
100.0% used
From Space: #其中一个Survivor区的内存分布
capacity = 3342336 (3.1875MB)
used = 234024 (0.22318267822265625MB)
free = 3108312 (2.9643173217773438MB)
7.001809512867647% used
To Space: #另一个Survivor区的内存分布
capacity = 3342336 (3.1875MB)
used = 0 (0.0MB)
free = 3342336 (3.1875MB)
0.0% used
PS Old Generation: #当前的Old区内存分布
capacity = 67108864 (64.0MB)
used = 67108816 (63.99995422363281MB)
free = 48 (4.57763671875E-5MB)
99.99992847442627% used
PS Perm Generation: #当前的 “持久代” 内存分布
capacity = 14417920 (13.75MB)
used = 14339216 (13.674942016601562MB)
free = 78704 (0.0750579833984375MB)
99.45412375710227% used
```
新生代内存回收就是采用空间换时间方式； ， ，
**统计一【jmap -histo】**：统计所有类的实例数量和所占用的内存容量
```powershell
[root@localhost ~]# jmap -histo 7243
num #instances #bytes class name
----------------------------------------------
1: 8969 19781168 [B
2: 1835 2296720 [I
3: 19735 2050688 [C
4: 3448 385608 java.lang.Class
5: 3829 371456 [Ljava.lang.Object;
6: 14634 351216 java.lang.String
7: 6695 214240 java.util.concurrent.ConcurrentHashMap$Node
8: 6257 100112 java.lang.Object
9: 2155 68960 java.util.HashMap$Node
10: 723 63624 java.lang.reflect.Method
11: 49 56368 [Ljava.util.concurrent.ConcurrentHashMap$Node;
12: 830 46480 java.util.zip.ZipFile$ZipFileInputStream
13: 1146 45840 java.lang.ref.Finalizer
......
```
**统计二【jmap -histo】**： ， ，
```shell
[root@localhost ~]# jmap -histo 7243 |grep Map|sort -k 2 -g -r|less
Total 96237 26875560
7: 6695 214240 java.util.concurrent.ConcurrentHashMap$Node
9: 2155 68960 java.util.HashMap$Node
18: 563 27024 java.util.HashMap
21: 505 20200 java.util.LinkedHashMap$Entry
16: 337 34880 [Ljava.util.HashMap$Node;
27: 336 16128 gnu.trove.THashMap
56: 163 6520 java.util.WeakHashMap$Entry
60: 127 6096 java.util.WeakHashMap
38: 127 10144 [Ljava.util.WeakHashMap$Entry;
53: 126 7056 java.util.LinkedHashMap
......
```
**统计三【jmap -histo】**：
```shell
[root@localhost ~]# jmap -histo 7243 | sort -n -r -k 2 | head -10
num #instances #bytes class name
----------------------------------------------
Total 96237 26875560
3: 19735 2050688 [C
6: 14634 351216 java.lang.String
1: 8969 19781168 [B
7: 6695 214240 java.util.concurrent.ConcurrentHashMap$Node
8: 6257 100112 java.lang.Object
5: 3829 371456 [Ljava.lang.Object;
4: 3448 385608 java.lang.Class
9: 2155 68960 java.util.HashMap$Node
2: 1835 2296720 [I
```
**统计四【jmap -histo】**：
```shell
[root@localhost ~]# jmap -histo 7243 | sort -n -r -k 3 | head -10
num #instances #bytes class name
----------------------------------------------
Total 96237 26875560
1: 8969 19781168 [B
2: 1835 2296720 [I
3: 19735 2050688 [C
4: 3448 385608 java.lang.Class
5: 3829 371456 [Ljava.lang.Object;
6: 14634 351216 java.lang.String
7: 6695 214240 java.util.concurrent.ConcurrentHashMap$Node
8: 6257 100112 java.lang.Object
9: 2155 68960 java.util.HashMap$Node
```
**dump注意事项**
- 在应用快要发生FGC的时候把堆数据导出来
， ，
- 查看快要发生FGC使用命令： < pid >
- 数据导出： < pid >
- 通过命令查看大对象： < pid > |less
**使用总结**
- 如果程序内存不足或者频繁GC， ，
- 要制作堆Dump可以直接使用jvm自带的jmap命令
- 可以先使用`jmap -heap`命令查看堆的使用情况，看一下各个堆空间的占用情况
- 使用`jmap -histo:[live]`查看堆内存中的对象的情况。如果有大量对象在持续被引用，并没有被释放掉，那就产生了内存泄露，就要结合代码，把不用的对象释放掉
- 也可以使用 `jmap -dump:format=b,file=<fileName>` 命令将堆信息保存到一个文件中，
- 在内存出现泄露、溢出或者其它前提条件下， ， ，
- 在用cms gc的情况下， ， ， ，
## jhat
jhat（ ） ， ， ， ， ， ， ，
```powershell
# 解析Java堆转储文件,并启动一个 web server
jhat heapDump.dump
```
## jconsole
jconsole(Java Monitoring and Management Console)是一个Java GUI监视工具， ， ， ， ， ， ，
**第一步**： ：
```powershell
JAVA_OPTS="$JAVA_OPTS -Djava.rmi.server.hostname=192.168.202.121 -Dcom.sun.management.jmxremote"
JAVA_OPTS="$JAVA_OPTS -Dcom.sun.management.jmxremote.port=12345"
JAVA_OPTS="$JAVA_OPTS -Dcom.sun.management.jmxremote.authenticate=true"
JAVA_OPTS="$JAVA_OPTS -Dcom.sun.management.jmxremote.ssl=false"
JAVA_OPTS="$JAVA_OPTS -Dcom.sun.management.jmxremote.pwd.file=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.101-3.b13.el7_2.x86_64/jre/lib/management/jmxremote.password"
```
**第二步**：配置权限文件
```powershell
[root@localhost bin]# cd /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.101-3.b13.el7_2.x86_64/jre/lib/management/
[root@localhost management]# cp jmxremote.password.template jmxremote.password
[root@localhost management]# vi jmxremote.password
```
monitorRole QED
controlRole chenqimiao
**第三步**：
```powershell
[root@localhost management]# chmod 600 jmxremote.password jmxremote.access
```
这样基本配置就结束了， ， ， ， ， ：
请将127.0.0.1修改为本地真实的IP,我的服务器IP是192.168.202.121：
** 第四步**：
## jvisualvm
jvisualvm(JVM Monitoring/Troubleshooting/Profiling Tool)同jconsole都是一个基于图形化界面的、可以查看本地及远程的JAVA GUI监控工具， ， ， ， ， ，
**Visual GC(监控垃圾回收器)**
Java VisualVM默认没有安装Visual GC插件， ， ， ， ： ** 工具->插件** 安装Visual GC， ：
**大dump文件**
从服务器dump堆内存后文件比较大（ ） ， ， ， ， ：
```shell
default_options="-J-Xms24m -J-Xmx192m"
```
再重启VisualVM就行了。
## jmc
jmc（ ） ， ，
JMC的最主要的特征就是JFR（ ） ， ， ， ，
### 启动JFR
在商业版本上面， ， `-XX:+UnlockCommercialFeatures -XX:+FlightRecorder` 来启动应用。启动之后， ，
- ** 通过Java Mission Control启动JFR**
打开Java Mission Control点击对应的JVM启动即可， （ ， ） ：
- 记录固定一段时间的事件（ ： ）
- 持续进行记录
- ** 通过命令行启动JFR**
通过在启动的时候，增加参数：`-XX:+FlightRecorderOptions=string` 来启动真正地事件记录，这里的 `string` 可以是以下值（ ， ， ） ：
- `name=name` ： （ ， ）
- `defaultrecording=<ture|false>` ： ， ， ，
- `setting=paths` ：
- `delay=time` ： ， （ ： ， ）
- `duration=time` ：
- `filename=path` ：
- `compress=<ture|false>` ： （ ）
- `maxage=time` ：在循环使用的缓存中，事件数据保存的最大时长
- `maxsize=size` ： （ ： ， ）
### 常用JFR命令
- 启动recording
命令格式：`jcmd process_id JFR.start [options_list]`，
- dump出循环缓存中的数据
命令格式：`jcmd process_id JFR.dump [options_list]`， ：
- `name=name` ：
- `recording=n` ： （ ）
- `filename=path` ：
- 查看进程中所有recording
命令格式：` jcmd process_id JFR.check [verbose]`， ，
- 停止recording
命令格式：` jcmd process_id JFR.stop [options_list]`， ：
- `name=name` ：
- `recording=n` ：
- `discard=boolean` ： ， ，
- `filename=path` ：写入数据的文件名称
### 命令启动JFR案例
- ** 第一步**： （ ） ， ，
- ** 第二步**： ，
```powershell
[root@localhost bin]# jcmd 12234 VM.unlock_commercial_features
12234: Commercial Features already unlocked.
```
- ** 第三步**： ， ：
```powershell
jcmd < PID > JFR.start name=test duration=60s [settings=template.jfc] filename=output.jfr
```
`template.jfc` （在 `$JAVA_HOME/jre/lib/jfr` 下有 `default.jfc` 和 `profile.jfc` 模板）的配置收集 `60s` 的JVM信息， `output.jfr` 中。一旦记录完成之后，就可以复制.jfr文件到你的工作环境使用jmc GUI来分析。它几乎包含了排查jvm问题需要的所有信息， ：
```powershell
[root@localhost bin]# jcmd 12234 JFR.start name=test duration=60s filename=output.jfr
12234: Started recording 6. The result will be written to: /root/zookeeper-3.4.12/bin/output.jfr
[root@localhost bin]# ls -l
-rw-r--r-- 1 root root 298585 6月 29 11:09 output.jfr
```
**JFR（ ）
- Java Mission Control的最主要的特征就是Java Flight Recorder。正如它的名字所示， ，
- JFR的基本操作就是开启哪些事件（ ： ） ， ， ， （ ） ，
- 事件的类型、缓存的大小、事件数据的存储方式等等都是通过JVM参数、Java Mission Control的GUI界面、jcmd命令来控制的。JFR默认是编译进程序的， ， ， ，
### JFR概况
， ， ：
我们可以看到， ： ， ， ， ，
### JFR内存视图
Java Mission Control 可以看到非常多的信息， ， （ ， ） ， ： ， ， ： ， ， ： ， ； ； ，
### JFR 代码视图
这张图也有很多tab， ：
### JFR事件视图
下图显示了事件的概述视图：
## EclipseMAT
虽然Java虚拟机可以帮我们对内存进行回收， ， （ ） ， ， ， ， ，
**GC Roots**
JAVA虚拟机通过可达性（ ， ， （ ） ， ，
- 一个在current thread（ ） （ ） （ ）
- 线程自身或者system class loader（ ）
- native code（ ）
**内存泄漏**
当对象无用了，但仍然可达（未释放），垃圾回收器无法回收。
**Java四种引用类型**
- Strong References（ ）
普通的java引用， ：
- Soft Reference（ ）
当对象是Soft Reference可达时， ， ， ，
- Weak Reference（ ）
WeakReference不会强制对象保存在内存中。它拥有比较短暂的生命周期， ， ， `Reference Queue` 中，
系统为我们提供了WeakHashMap， ， ， ， ， ， ， ， ， ，
ReferenceQueue可以让你很容易地跟踪dead references。WeakReference类的构造函数有一个ReferenceQueue参数， ， ，
- Phantom Reference（ ）
其余Soft/Weak Reference区别较大是它的get()方法总是返回null。这意味着你只能用Phantom Reference本身， ） ， ， （ ， ） ，
**MAT视图与概念**
- **Shallow Heap**
Shallow Size就是对象本身占用内存的大小， ， （ ） （ ） ：
```java
public class String {
public final class String {8 Bytes header
private char value[]; 4 Bytes
private int offset; 4 Bytes
private int count; 4 Bytes
private int hash = 0; 4 Bytes
// ......
}
// "Shallow size“ of a String ==24 Bytes12345678
```
Java的对象成员都是些引用。真正的内存都在堆上， ， ，
- **Retained Heap**
Retained Heap值的计算方式是将Retained Set中的所有对象大小叠加。或者说， ， （ ）
一个ArrayList持有100000个对象， ， × ， ， （ ， ）
- **Histogram**
可列出每一个类的实例数。支持正则表达式查找，
- **Dominator Tree**
对象之间dominator关系树。如果从GC Root到达Y的的所有path都经过X， ，
- **Path to GC Roots**
，
意思是查看排除虚引用/弱引用/软引用等的引用链，因为被虚引用/弱引用/软引用的对象可以直接被GC给回收， （ ） ， ， ，
查看当前Object所有引用,被引用的对象：
- List objects with （ ）
- incoming references 引用到该对象的对象
- outcoming references 被该对象引用的对象
- Show objects by class （ ）
- incoming references 引用到该对象的对象
- outcoming references 被该对象引用的对象
- **OQL(Object Query Language)**
类似SQL查询语言： ： ： ：
```mysql
select * from com.example.mat.Listener
# 查找size＝
select * from java.util.ArrayList where size=0 and modCount=01
# 查找所有的Activity
select * from instanceof android.app.Activity
```
- ** 内存快照对比**
方式一： （ ）
方式二： （ ， ）
**MAT内存分析实战**
- ** 实战一：内存泄漏分析**
查找导致内存泄漏的类。既然环境已经搭好， ，
- 查找目标类
如果在开发过程中， ， ， ， ， ，
`select * from instanceof android.app.Activity`
- Paths to GC Roots：
查看一个对象到RC Roots是否存在引用链。要将虚引用/弱引用/软引用等排除，因为被虚引用/弱引用/软引用的对象可以直接被GC给回收
- 分析具体的引用为何没有被释放，并进行修复
**小技巧：**
- 当目的不明确时， ， ， ，
- 如果大对象筛选看不出区别， ，
- 直接按照包名直接查看GC引用链， ， ， ， ， ，
所以有时候进行MAT分析还是需要一些经验，
- ** 实战二：集合使用率分析**
集合在开发中会经常使用到， ， （ ， ） ， ， ，
- ** 筛选目标对象**
- **Show Retained Set（ ）
- ** 筛选指定的Object（ ， ）
- ** 查看指定类的Immediate dominators**
**Collections fill ratio**
这种方式只能查看那些具有预分配内存能力的集合， ， ：
- ** 实战三：
当Hash集合中过多的对象返回相同Hash值的时候， （ ） ，
- **Map Collision Ratio**
检测每一个HashMap或者HashTable实例并按照碰撞率排序：
- ** 查看Immediate dominators**
- ** 通过HashEntries查看key value**
- **Array等其它集合分析方法类似**
- ** 实战四：
- ** 通过OQL查询empty并且未修改过的集合：
```mysql
select * from java.util.ArrayList where size=0 and modCount=01
select * from java.util.HashMap where size=0 and modCount=0
select * from java.util.Hashtable where count=0 and modCount=012
```
- **Immediate dominators(查看引用者)**
- ** 计算空集合的Retained Size值，
## 🔥火焰图
火焰图是用来分析程序运行瓶颈的工具。火焰图也可以用来分析 Java 应用。
### 环境安装
确认你的机器已经安装了**git、jdk、perl、c++编译器**。
#### 安装Perl
```shell
wget http://www.cpan.org/src/5.0/perl-5.26.1.tar.gz
tar zxvf perl-5.26.1.tar.gz
cd perl-5.26.1
./Configure -de
make
make test
make install
```
wget后面的路径可以按需更改。安装过程比较耗时间，
#### C++编译器
```shell
apt-get install g++
```
一般用于编译c++程序， ，
#### clone相关项目
下载下来所需要的两个项目（ ） ：
```shell
git clone https://github.com/jvm-profiling-tools/async-profiler
git clone https://github.com/brendangregg/FlameGraph
```
#### 编译项目
下载好以后， ， ：
```shell
cd async-profiler
make
```
### 生成文件
#### 生成火焰图数据
可以从 github 上下载 [async-profiler ](https://github.com/jvm-profiling-tools/async-profiler ) 的压缩包进行相关操作。进入async-profiler项目的目录下， ：
```shell
./profiler.sh -d 60 -o collapsed -f /tmp/test_01.txt ${pid}
```
上面的-d表示的是持续时长， ， ， ， ， （ ） ， ， ， ，
#### 生成svg文件
上一步产生的文件里的内容，肉眼是很难看懂的，所以现在[FlameGraph](https://github.com/brendangregg/FlameGraph)的作用就体现出来了，它可以读取该文件并生成直观的火焰图，现在进入该项目目录下面，执行如下语句：
```shell
perl flamegraph.pl --colors=java /tmp/test_01.txt > test_01.svg
```
因为是perl文件， ， ， ， ， ， ， ，
#### 展示火焰图
现在下载下来该文件，使用浏览器打开，效果如下：
### 火焰图案例
生成的[火焰图案例](images/DevOps/火焰图案例.svg)如下：
#### 瓶颈点1
CoohuaAnalytics$KafkaConsumer:::send方法中Gzip压缩占比较高。已经定位到方法级别， ， ， ：
#### 瓶颈点2
展开2这个波峰， ， ：
直接看代码：
果然如推断， ：
#### 瓶颈点3
展开波峰3， ：
定位到具体的代码， ：
# Linux Command
595208882@qq.com
4 years ago
