1. 背景

有时候会遇到一些疑难杂症，并且监控插件并不能一眼立马发现问题的根源。这时候就需要登录服务器进一步深入分析问题的根源。那么分析问题需要有一定的技术经验积累，并且有些问题涉及到的领域非常广，才能定位到问题。所以，分析问题和踩坑是非常锻炼一个人的成长和提升自我能力。如果我们有一套好的分析工具，那将是事半功倍，能够帮助大家快速定位问题，节省大家很多时间做更深入的事情。

2. 说明

本篇文章主要介绍各种问题定位的工具以及会结合案例分析问题。

3. 分析问题的方法论套用5W2H方法，可以提出性能分析的几个问题

• What-现象是什么样的
• When-什么时候发生
• Why-为什么会发生
• Where-哪个地方发生的问题
• How much-耗费了多少资源
• How to do-怎么解决问题
  

4. cpu4.1 说明

针对应用程序，我们通常关注的是内核CPU调度器功能和性能。

线程的状态分析主要是分析线程的时间用在什么地方，而线程状态的分类一般分为：

• on-CPU：执行中，执行中的时间通常又分为用户态时间user和系统态时间sys。
• off-CPU：等待下一轮上CPU，或者等待I/O、锁、换页等等，其状态可以细分为可执行、匿名换页、睡眠、锁、空闲等状态。
  
  

如果大量时间花在CPU上，对CPU的剖析能够迅速解释原因；如果系统时间大量处于off-cpu状态，定位问题就会费时很多。但是仍然需要清楚一些概念：

• 处理器
• 核
• 硬件线程
• CPU内存缓存
• 时钟频率
• 每指令周期数CPI和每周期指令数IPC
• CPU指令
• 使用率
• 用户时间／内核时间
• 调度器
• 运行队列
• 抢占
• 多进程
• 多线程
• 字长
  & v7 X* F) i1 s. m

4.2 分析工具

说明:

• uptime，vmstat，mpstat，top，pidstat 只能查询到cpu及负载的的使用情况。
• perf可以跟着到进程内部具体函数耗时情况，并且可以指定内核函数进行统计，指哪打哪。
  ; F: n" l  S5 k( K; B# O

4.3 使用方式

1. 
   
2. //查看系统cpu使用情况top
   
3. //查看所有cpu核信息mpstat -P ALL 1
   
4. //查看cpu使用情况以及平均负载vmstat 1
   % e% B6 |; O& I' r: x
5. //进程cpu的统计信息pidstat -u 1 -p pid
   
6. //跟踪进程内部函数级cpu使用情况 perf top -p pid -e cpu-clock

复制代码

5. 内存
& ]  ^% a! W2 E0 w* X5.1 说明
内存是为提高效率而生，实际分析问题的时候，内存出现问题可能不只是影响性能，而是影响服务或者引起其他问题。同样对于内存有些概念需要清楚：

• 主存
• 虚拟内存
• 常驻内存
• 地址空间
• OOM
• 页缓存
• 缺页
• 换页
• 交换空间
• 交换
• 用户分配器libc、glibc、libmalloc和mtmalloc
• LINUX内核级SLUB分配器
  6 Z+ D; L9 s- V$ w+ b6 T, ~6 F& r

5.2 分析工具

说明：

• free，vmstat，top，pidstat，pmap只能统计内存信息以及进程的内存使用情况。
• valgrind 可以分析内存泄漏问题。
• dtrace 动态跟踪。需要对内核函数有很深入的了解，通过D语言编写脚本完成跟踪。
  
  

5.3 使用方式
- v6 c: }3 Y$ R7 N

1. 
   
2. //查看系统内存使用情况free -m
   ( y7 A% R) A; y! z- C
3. //虚拟内存统计信息vmstat 1
   
4. //查看系统内存情况top
   * L/ [' F3 x/ U  y' l0 P" X
5. //1s采集周期，获取内存的统计信息pidstat -p pid -r 1
   
6. //查看进程的内存映像信息pmap -d pid
   , t( P2 ^+ N+ }& Y
7. //检测程序内存问题valgrind --tool=memcheck --leak-check=full --log-file=./log.txt  ./程序名

复制代码

( o0 H$ C' W/ n  ?; w% O7 @) q3 |
6. 磁盘IO
% {% n9 l  U! r+ b6.1 说明
磁盘通常是计算机最慢的子系统，也是最容易出现性能瓶颈的地方，因为磁盘离 CPU 距离最远而且 CPU 访问磁盘要涉及到机械操作，比如转轴、寻轨等。访问硬盘和访问内存之间的速度差别是以数量级来计算的，就像1天和1分钟的差别一样。要监测 IO 性能，有必要了解一下基本原理和 Linux 是如何处理硬盘和内存之间的 IO 的。

在理解磁盘IO之前，同样我们需要理解一些概念，例如：

• 文件系统
• VFS
• 文件系统缓存
• 页缓存page cache
• 缓冲区高速缓存buffer cache
• 目录缓存
• inode
• inode缓存
• noop调用策略
  * }& ~. W2 @  j9 U

6.2 分析工具

6.3 使用方式

1. 
   
2. //查看系统io信息iotop
   
3. //统计io详细信息iostat -d -x -k 1 10
   & _/ P/ e( |+ v* I+ D: R! N
4. //查看进程级io的信息pidstat -d 1 -p  pid
   
5. //查看系统IO的请求，比如可以在发现系统IO异常时，可以使用该命令进行调查，就能指定到底是什么原因导致的IO异常perf record -e block:block_rq_issue -ag^Cperf report

复制代码

7. 网络
- s% Q& T  l1 ^" g7.1 说明
$ M) ?/ M! h0 W. L  k% y1 A网络的监测是所有 Linux 子系统里面最复杂的，有太多的因素在里面，比如：延迟、阻塞、冲突、丢包等，更糟的是与 Linux 主机相连的路由器、交换机、无线信号都会影响到整体网络并且很难判断是因为 Linux 网络子系统的问题还是别的设备的问题，增加了监测和判断的复杂度。现在我们使用的所有网卡都称为自适应网卡，意思是说能根据网络上的不同网络设备导致的不同网络速度和工作模式进行自动调整。


7.2 分析工具

7.3 使用方式
+ F, T, f, ?; J% s, ~+ O2 ^4 o

1. 
   / V- U8 c% B' t& y  S
2. //显示网络统计信息netstat -s
   # e1 @! w+ H& H4 Q  O% X
3. //显示当前UDP连接状况netstat -nu
   
4. //显示UDP端口号的使用情况netstat -apu
   
5. //统计机器中网络连接各个状态个数netstat -a | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'
   
6. //显示TCP连接ss -t -a//显示sockets摘要信息ss -s//显示所有udp socketsss -u -a//tcp,etcp状态sar -n TCP,ETCP 1
   3 p4 U2 ?6 a+ J. L) T* N
7. //查看网络IOsar -n DEV 1//抓包以包为单位进行输出tcpdump -i eth1 host 192.168.1.1 and port 80 //抓包以流为单位显示数据内容tcpflow -cp host 192.168.1.1

复制代码

5 D3 o; ]- e* V2 p8. 系统负载
8.1 说明
) W+ u# j% g0 P: [Load 就是对计算机干活多少的度量（WikiPedia：the system Load is a measure of the amount of work that a compute system is doing）简单的说是进程队列的长度。Load Average 就是一段时间（1分钟、5分钟、15分钟）内平均Load。


8.2 分析工具

8.3 使用方式
" E' M  C  v0 ^$ k  _* w

1. 
   
2. //查看负载情况uptimetopvmstat
   
3. //统计系统调用耗时情况strace -c -p pid
     B/ }0 a0 a8 q
4. //跟踪指定的系统操作例如epoll_waitstrace -T -e epoll_wait -p pid
   
5. //查看内核日志信息dmesg

复制代码

9. 火焰图
7 d0 u/ h# w0 m) n6 O8 Y9.1 说明
: U( ~- m7 N0 @8 b$ J+ F. c( k火焰图（Flame Graph是 Bredan Gregg 创建的一种性能分析图表，因为它的样子近似 ?而得名。火焰图主要是用来展示 CPU的调用栈。y 轴表示调用栈，每一层都是一个函数。调用栈越深，火焰就越高，顶部就是正在执行的函数，下方都是它的父函数。x 轴表示抽样数，如果一个函数在 x 轴占据的宽度越宽，就表示它被抽到的次数多，即执行的时间长。注意，x 轴不代表时间，而是所有的调用栈合并后，按字母顺序排列的。火焰图就是看顶层的哪个函数占据的宽度最大。只要有”平顶”（plateaus），就表示该函数可能存在性能问题。颜色没有特殊含义，因为火焰图表示的是 CPU 的繁忙程度，所以一般选择暖色调。
! F6 g0 m4 x# I) E$ `

常见的火焰图类型有 On-CPU、Off-CPU、Memory、Hot/Cold、Differential等等。

9.2 安装依赖库

1. 
   & X& s: B: O" ]5 Y
2. //安装systemtap，默认系统已安装yum install systemtap systemtap-runtime
   
3. //内核调试库必须跟内核版本对应，例如：uname -r 2.6.18-308.el5kernel-debuginfo-2.6.18-308.el5.x86_64.rpmkernel-devel-2.6.18-308.el5.x86_64.rpmkernel-debuginfo-common-2.6.18-308.el5.x86_64.rpm
   + \: j9 w1 O) S- ^" T1 @4 ?8 T6 I
4. //安装内核调试库debuginfo-install --enablerepo=debuginfo search kerneldebuginfo-install --enablerepo=debuginfo  search glibc

复制代码

: H' B+ R$ r( T
, Q1 o) G, A! \0 {# Q9.3 安装

1. <font face="Tahoma"><font size="3"><font color="black">
   ) W) F# x+ R/ t( D5 w
2. git clone http://github.com/lidaohang/quick_location.gitcd quick_location</font></font></font>

复制代码

4 a. ]7 P, Z; @7 X2 d7 \

9.4 CPU级别火焰图
% s& @! A% U6 u5 G7 `

cpu占用过高，或者使用率提不上来，你能快速定位到代码的哪块有问题吗？

一般的做法可能就是通过日志等方式去确定问题。现在我们有了火焰图，能够非常清晰的发现哪个函数占用cpu过高，或者过低导致的问题。

9.4.1 on-CPU
cpu占用过高，执行中的时间通常又分为用户态时间user和系统态时间sys。使用方式：

1. 
   
2. //on-CPU usersh ngx_on_cpu_u.sh pid
   , f! Z8 Z6 ?) F* e
3. //进入结果目录 cd ngx_on_cpu_u
   . O+ X0 B' \6 E9 B
4. //on-CPU kernelsh ngx_on_cpu_k.sh pid
   4 X1 I4 ~, {+ S9 n: z- ~
5. //进入结果目录 cd ngx_on_cpu_k
   
6. //开一个临时端口 8088 python -m SimpleHTTPServer 8088//打开浏览器输入地址127.0.0.1:8088/pid.svg

复制代码

% B9 R0 i  g# z% O3 ?
9 c0 C0 S3 @, g" ~5 _DEMO：
& U. y7 n8 E; `6 X2 X

1. 
   7 _# \* |8 L2 C: a% R2 j7 h- X
2. #include <stdio.h>
   ( c- k. V1 K$ u! o& n) Z! o
3. #include <stdlib.h>
   
4. 
   ; ]& z$ J/ t$ G5 c
5. void foo3()
   ! P, u: O& ?, t5 V: |! _
6. {  
   . `4 _( t  b. M% l1 v2 ~% ~. j
7. }
   ! z! A: o: C7 S+ z/ E# r; o5 o
8. 
   + c; p" E  D# X- Q4 Z
9. void foo2(){  
   9 ]' n2 f) f7 ~4 q+ v% N( K/ C
10.   int i;  
    # R% v' O8 M1 \- ~6 y. P" e: h
11.   for(i=0 ; i < 10; i++)      
    
12.     foo3();
    , M3 c& z* x- d' N5 W$ m
13. }
    " _4 n% H% u* _: Z
14. 
    
15. void foo1()
    
16. {  
    / q! y3 [% R; ^! d- D
17.   int i;
    9 H: `5 G+ N' n. Y2 b9 P: b
18.   for(i = 0; i< 1000; i++)
    
19.       foo3();
    * p0 Q$ G" h6 H* b* n* H
20. }
    * S( I3 @* p" ?; r& Y( j) S8 _
21. 
    
22. int main(void)
    / P; Z- {3 m( D" p6 _
23. {  
    
24.   int i;  
    $ c* h" G* e6 ?" f2 _- `
25.   for( i =0; i< 1000000000; i++) {      
    ( S$ C, b  V4 B7 ^+ Q6 n- T
26.     foo1();      
    % @( L& @$ u. G# I
27.     foo2();  
    
28.   }
    " [3 b% u0 M) @. O' @$ N' v
29. }

复制代码

1 ^% d8 |( C# H( l0 n
* v$ z* @5 `' r3 j

DEMO火焰图：

9.4.2 off-CPU

cpu过低，利用率不高。等待下一轮CPU，或者等待I/O、锁、换页等等，其状态可以细分为可执行、匿名换页、睡眠、锁、空闲等状态。

使用方式：

1. 
   
2. // off-CPU usersh ngx_off_cpu_u.sh pid
   
3. //进入结果目录cd ngx_off_cpu_u
   3 c/ w, x; s) H- `0 Q" z; G9 a1 X
4. //off-CPU kernelsh ngx_off_cpu_k.sh pid
   ! h+ J& d2 O2 m
5. //进入结果目录cd ngx_off_cpu_k
   
6. //开一个临时端口8088python -m SimpleHTTPServer 8088
   5 w  i. p; d- E( ^1 B) g
7. //打开浏览器输入地址127.0.0.1:8088/pid.svg

复制代码

& U" y7 F" h  \+ _8 g* W$ K

官网DEMO：

9.5 内存级别火焰图

如果线上程序出现了内存泄漏，并且只在特定的场景才会出现。这个时候我们怎么办呢？有什么好的方式和工具能快速的发现代码的问题呢？同样内存级别火焰图帮你快速分析问题的根源。

使用方式：

1. 
   . W( y& h( j' n7 S+ G1 d
2. sh ngx_on_memory.sh pid
   
3. //进入结果目录cd ngx_on_memory
   
4. //开一个临时端口8088python -m SimpleHTTPServer 8088
   $ y8 I) k4 R) D
5. //打开浏览器输入地址127.0.0.1:8088/pid.svg

复制代码

0 W7 M0 t5 I8 P, C2 E% r+ d
# w+ J; L1 O2 ?. b, J! O0 v

官网DEMO：

9.6 性能回退-红蓝差分火焰图

你能快速定位CPU性能回退的问题么？如果你的工作环境非常复杂且变化快速，那么使用现有的工具是来定位这类问题是很具有挑战性的。当你花掉数周时间把根因找到时，代码已经又变更了好几轮，新的性能问题又冒了出来。主要可以用到每次构建中，每次上线做对比看，如果损失严重可以立马解决修复。

通过抓取了两张普通的火焰图，然后进行对比，并对差异部分进行标色：红色表示上升，蓝色表示下降。差分火焰图是以当前（“修改后”）的profile文件作为基准，形状和大小都保持不变。因此你通过色彩的差异就能够很直观的找到差异部分，且可以看出为什么会有这样的差异。

使用方式：

1. 
   : ]& ]: z) G* H2 S# f! Z2 m1 Z# I) F
2. cd quick_location
   
3. //抓取代码修改前的profile 1文件perf record -F 99 -p pid -g -- sleep 30perf script > out.stacks1
   9 ~) q$ I1 A% e" t4 H! Y4 M
4. //抓取代码修改后的profile 2文件perf record -F 99 -p pid -g -- sleep 30perf script > out.stacks2
   6 R, \* z% p' v  O. r8 X2 m
5. //生成差分火焰图:./FlameGraph/stackcollapse-perf.pl ../out.stacks1 > out.folded1./FlameGraph/stackcollapse-perf.pl ../out.stacks2 > out.folded2./FlameGraph/difffolded.pl out.folded1 out.folded2 | ./FlameGraph/flamegraph.pl > diff2.svg

复制代码

# l& L9 \; L7 a; S* ^7 Q( i

DEMO：

1. 
   
2. //test.c
   ) Y9 q! u# `+ S( L+ T% b. L2 f6 K9 [
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. 
   
6. void foo3()
   
7. {  
   
8. }
   
9. 
   * A3 A1 l7 f+ g, ?! h
10. void foo2()
    1 M' J/ c$ a* v0 l: P2 {! e/ o
11. {  
    
12.   int i;  
    
13.   for(i=0 ; i < 10; i++)
    # Z) C' w5 W8 r* k6 I
14.       foo3();
    
15. }
    
16. 
    " D  r7 n2 f. ~* [
17. void foo1()
    
18. {  
    
19.   int i;  
    ) x, Y. O" a; l1 v  e% j
20.   for(i = 0; i< 1000; i++)
    - y# {' s  `+ c
21.       foo3();
      t) h; d* ^8 ?) u, f
22. }
    : `: @% B2 e: ]& i$ l
23. 
    
24. int main(void)
    1 u1 A7 h% |- ]/ |) ~! @- ~
25. {  
    " H; A5 B% x9 j  L& j
26.   int i;
    + K1 V$ T0 T$ r8 c8 e) a* R5 ]: z' G
27.   for( i =0; i< 1000000000; i++) {
    
28.       foo1();
    . `4 h! x. M3 O9 {3 P/ k
29.       foo2();  
    
30.   }
    + ]3 S% i* ?  C- d/ Z3 v0 @' K
31. }
    3 E: q) k; w9 X" m6 ]1 b& p5 ]/ T# s% ?) R
32. 
    3 M) ]! s/ r( y4 h
33. //test1.c
    ! Z9 e/ G/ G$ c4 ^4 H" ~
34. #include <stdio.h>
    , I/ l( v" M' G  l6 Z4 D7 i, Y
35. #include <stdlib.h>
    * Z6 e' e* V, U- O: o, t
36. 
    . U' ~6 m( \3 |& s' R. ]
37. void foo3()
    
38. {
    % b% F7 f7 r3 M4 W5 _# l2 J/ T- _
39. 
    
40. }
    : N/ t1 ~, }, f! k. C
41. 
    ; d. q& o1 ?. N5 f/ V1 [
42. void foo2()
    
43. {
    ) g' i$ M6 \6 H! h
44.   int i;
    
45.   for(i=0 ; i < 10; i++)
    9 \6 O  m4 f7 {$ A# M
46.          foo3();
    & i$ B1 ~* U6 V8 j2 {! c
47. }
    . r* x* L. ]4 z- m$ A- U
48. 
    % }) c3 e. o: m
49. void foo1()
    
50. {  
    ( _* m' m8 k3 q) p' d
51.   int i;  
    0 }/ v& ~+ Z$ ?- S, T5 N6 ^8 J+ t9 a
52.   for(i = 0; i< 1000; i++)     
    
53.     foo3();
    
54. }
    $ u. R; e$ C7 I% j( y* X
55. 
    2 J2 ?5 k" `' U3 Z' I) t% M
56. void add()
    : |0 B9 D) D* p) P: c9 a- z( d
57. {  
    % y) x1 V* t$ H# T
58.   int i;  
    
59.   for(i = 0; i< 10000; i++)     
    
60.   foo3();
    
61. }
    ' ~! s' O  s4 |  r7 h+ S9 k5 s. t; l2 M
62. 
    * h3 }7 U/ Z$ q3 p0 C
63. int main(void)
    
64. {  
    
65.   int i;  
    3 j4 h  n2 k1 {. M! u7 h* `
66.   for( i =0; i< 1000000000; i++) {
    : |% I3 W# B* R4 \, i# x; Y
67.     foo1();
    
68.     foo2();
    ( L/ `2 T, L, X" N! ^' w% V
69.     add();
    
70.   }
    
71. }
    ! D- ~3 w' ]* e$ ~; L

复制代码

DEMO红蓝差分火焰图：
5 F& k0 f( o& K4 `' ~

10. 案例分析10.1 接入层nginx集群异常现象通过监控插件发现在 2017.09.25 19 点nginx集群请求流量出现大量的499，5xx状态码。并且发现机器cpu使用率升高，目前一直持续中。10.2 分析nginx相关指标

a) **分析nginx请求流量：

结论：

通过上图发现流量并没有突增，反而下降了，跟请求流量突增没关系。

b) **分析nginx响应时间

结论：

通过上图发现nginx的响应时间有增加可能跟nginx自身有关系或者跟后端upstream响应时间有关系。

c) **分析nginx upstream响应时间

结论：

通过上图发现nginx upstream 响应时间有增加，目前猜测可能后端upstream响应时间拖住nginx，导致nginx出现请求流量异常。

10.3 分析系统cpu情况

a) **通过top观察系统指标

top

结论：

发现nginx worker cpu比较高

b) **分析nginx进程内部cpu情况

perf top -p pid

结论：

发现主要开销在free,malloc,json解析上面

10.4 火焰图分析cpu
a) **生成用户态cpu火焰图

1. 
   # ?; }. A4 |2 ~4 O$ ]
2. //on-CPU usersh ngx_on_cpu_u.sh pid
   
3. //进入结果目录cd ngx_on_cpu_u
   
4. //开一个临时端口8088python -m SimpleHTTPServer 8088
   & P, \* t; Z  ~: q, o0 u" k5 Y/ r
5. //打开浏览器输入地址127.0.0.1:8088/pid.svg

复制代码

结论：

发现代码里面有频繁的解析json操作，并且发现这个json库性能不高，占用cpu挺高。

10.5 案例总结

a) 分析请求流量异常，得出nginx upstream后端机器响应时间拉长

b) 分析nginx进程cpu高，得出nginx内部模块代码有耗时的json解析以及内存分配回收操作

10.5.1 深入分析

根据以上两点问题分析的结论，我们进一步深入分析。

后端upstream响应拉长，最多可能影响nginx的处理能力。但是不可能会影响nginx内部模块占用过多的cpu操作。并且当时占用cpu高的模块，是在请求的时候才会走的逻辑。不太可能是upstram后端拖住nginx，从而触发这个cpu的耗时操作。

10.5.2 解决方式

遇到这种问题，我们优先解决已知的，并且非常明确的问题。那就是cpu高的问题。解决方式先降级关闭占用cpu过高的模块，然后进行观察。经过降级关闭该模块cpu降下来了，并且nginx请求流量也正常了。之所以会影响upstream时间拉长，因为upstream后端的服务调用的接口可能是个环路再次走回到nginx。