请选择 进入手机版 | 继续访问电脑版

IT运维管理,ITIL,ITSS,ITSM,ISO20000-ITIL先锋论坛

 找回密码
 微信、QQ、手机号一键注册

扫描二维码登录本站

QQ登录

只需一步,快速开始

艾拓先锋
搜索
查看: 567|回复: 0

从运维角度解析APM之一键式线程分析实现

[复制链接]
来自- 广东广州

参加活动:0

组织活动:12

发表于 2017-8-16 15:21:01 | 显示全部楼层 |阅读模式 来自- 广东广州
此次分享会从服务化的运维角度的一个重点问题出发,带领大家了解自动化运维中的APM,希望能为大家带来新鲜的启示。

* ^$ ]& n- K" K- W  d( V3 w' \! y
分享大纲:
  • 自动化运维中的APM
  • 为什么需要一键式线程分析
  • 一键式线程分析的实现原理
  • 应用场景解析
    ) }# [. R0 A% N0 b  E8 {
: p1 z( i$ ^9 X# V

一、自动化运维中的APM

6 F" k# \1 ?  ]  S% s$ w1 p
先谈谈自动化运维的概念,它是指利用系统化手段,将IT运维的流程,管理,执行,反馈,优化等诸多方面实现高度自动化处理。IT运维发展经历了几个阶段:

  Z: Y0 M1 C# g0 e
  • 初始期:这个时期是IT运维的软件工具,流程初始化的时期,工具的目标仅仅只是计算机化,流程尚属摸索阶段,还没有形成行业共识。
  • 流程形成期:这个时期ITIL出现了,ITIL强调流程管理质量,也就是通过流程和制度来管理人,业务,系统和设施。在这个时期,DevOps被提出,当然DevOps并不像ITIL是一种流程,它是一种理念强调打破开发,测试,运维的边界。这个时期也可以被看成是自动化运维的萌芽期
  • DevOps阶段:通过对ITIL的反思和整理,同时迎来DevOps的工具链已经比较成熟,这个时期自动化运维正式进入历史舞台,它更加强调从运维流程,运维措施等层面实现完全的自动化,在特定情况下,甚至实现无人干预。
    $ W8 A0 Z% P: m. d/ V

# t9 I# q7 S4 a# \
那么自动化运维到底给IT运维带来了哪些变化呢?我认为有以下四个方面:

% E1 \# l# T8 m0 W9 i+ c
  • 执行角度:从人工执行转型成系统化执行
  • 管理角度:从以人工界面管理转型成无界面系统化调度
  • 模式角度:从以人为驱动的运维模式转型成系统自我驱动的运维模式
  • 工具角度:从分散的运维工具转型成一体化协作的运维平台
    $ C/ B" F. Q( x% p- Z) m

) f% h$ }2 V& @8 s$ A/ _4 @
在自动化运维中,应用运维尤其重要。应用运维的关键是实现有效的应用性能管理,即APM。APM包含两个关键问题:
0 v6 c! L5 m- C
  • 实时监控:通过技术手段获取各种指标(业务,应用,基础设施),实现运维可视化,精确的报警等
  • 问题诊断:通过技术手段捕获问题现场,对问题现场进行自动化分析,并导出问题线索,甚至挖掘问题根因
    & G4 X9 X1 c/ H- {4 K& f

2 G5 ^0 {) x8 v
本次分享的主要话题是问题诊断,它之所以重要,是因为在运维过程中往往因为不能及时的发现问题,解决问题,导致运维的时效下降,甚至导致业务阻断。所以有效提高问题诊断的时效,是提升运维效率的重点。

  G+ p1 c" T. R0 F4 p" X" _/ m
那么问题诊断又面临哪些挑战呢?可以从以下几个方面来看:

5 N% _2 t3 z  q! O6 z- z  J
  • 微服务化,容器化的双重规模效应:微服务架构带来的直接效应是由于服务功能的拆分,服务类型变多,从而服务集群的数量变多,规模变大;同时,微服务通常采用容器技术实现部署,容器技术使得服务可部署实例大大高于虚拟机的数量,从而进一步促使规模变大。
  • 容器化隔离导致常规APM手段失效:容器技术的核心主要是利用Namespace和CGroup实现进程级隔离,而常规APM手段是利用工具对目标进程进行采集,例如使用jstack获得某jvm进程的线程dump。这种方式由于进程隔离,而变得不可用。
  • 高实效性要求,更短的MTTR(平均故障恢复时间):以互联网为主导的IT运维要求越来越高的时效性,这种时效的要求逐渐的超过了人+工具,它要求能多快恢复就多快恢复。
    8 {3 k% ^- h5 Q
* w; v! E# Z+ P1 W* W* U0 K: |! b
那么在自动化运维中,APM又涵盖哪些内容呢?其实涵盖的内容很多,在问题诊断这个方向上至少包含以下几种:

* ~$ F$ _# j" c4 @  `
0?wx_fmt=png.jpg
$ H$ P; ^/ w: @% _! |1 v% m
  • 线程诊断分析:这是本此分享的重点,稍后会详细讲解。之所以线程分析是问题诊断的重要手段,是因为线程是计算资源分配的直接体现;线上问题都跟线程的工作行为有关;线程可以关联代码逻辑,而通常代码逻辑是造成线上问题的主要因素
  • 慢操作跟踪:某个请求很缓慢,也是常见问题,常见的慢操作包括SQL、MQ、Redis、Mongo、Http等
  • 服务调用链跟踪:调用链是用来跟踪服务之间调用最直接的手段,通过调用链可以快速定位哪个服务是问题的根因
  • 客户端体验跟踪:是通过收集Web/App客户端呈现的用户操作的性能数据,来帮助分析和定位用户体验方面的问题
  • 主动健康巡检探测:通过定期的对应用进行探测以及执行与应用健康相关的状态收集来提早发现潜在问题的手段。

    ! A. y6 _) x" W8 [# l

- u4 }6 _/ Z5 i

二、为什么需要一键式线程分析

" r' }, v$ c. r- x/ |
上面已经谈到线程分析的重要性,接下来说说为什么需要一键式线程分析?我们先来看一个经典的运维问题:

, u) ]+ [- j; O+ k1 C/ S% E. a; o
  • 发现或被通知某个机器上CPU很高(经典的监控系统)
  • 运维人员登录堡垒机,没有带电脑是致命的,或许还需要短信验证码
  • 人工找到报CPU高的机器,使用某种SSH客户端登录到系统
  • 输入top命令
  • 人眼观察哪个进程CPU高,找到那个高CPU的进程,获取PID
  • 输入top -Hp PID
  • 人眼观察哪些线程CPU高,然后截图保存备用
  • 输入jstack PID > xxx.threaddump, 输出java thread dump文件
  • 通过堡垒机下载刚才输出的java thread dump文件
  • 使用java thread dump分析工具打开dump文件
  • 从刚才的截图中找出高CPU的TID(线程号),然后需要转换成16进制
  • 人眼在分析工具中定位到那个高CPU的线程,然后找到对应的代码

    3 p9 i" V" \+ f$ d
+ f# @# u! ?  A& m; `( z
通过上面实现线程分析的运维过程,我们可以看到以下问题:
- t1 i( v6 O% d; u+ U3 R/ C6 `1 p
  • 过度专业化:对于有经验的运维人员来说是常规技能,但如今运维(DevOps期望人人参与运维)的参与方包括了开发,测试,运维,甚至运营的人员,并不是人人都能有这些专业知识。
  • 很被动:需要人工的主动介入。如果人休假,或没有专业设备(堡垒机登录,线程分析软件等),将无法进行
  • 很低效:超长的人工驱动链路,人眼搜索,纯手工分析
  • 无法并行:更好的实效来源于并行化,人工处理是串行的。举例:如果是多个进程CPU高,那么需要把上面的多数步骤都重复一遍,耗时会更长

    # M: f; e0 x, A( G
7 j* O. u  t) \! D" x
此外,大数据甚至是人工智能等相关技术也正在被引入运维领域,而实现自动化运维也提出以下要求:

* I$ J! i. W' I% S: j! R0 l' t
  • 诊断数据需要统一管理:人工收集数据,没有统一的存储,也无法提供随时查询的能力
  • 知识沉淀,案例演练:团队希望将运维知识沉淀传承,能够回溯案例
  • 自动分析的可能:问题诊断往往有模式可循,只有将模式抽象出来,让系统可以使用,才能实现真正的自动化
  • 大数据分析的来源:利用大数据工具对各种诊断数据进行深入挖掘,发现新知识和规律
    * c5 g. b; n( a# i1 L% [4 ?4 i$ T

8 h1 H2 I  G3 j" }$ K
那什么是一键式线程分析?我认为可以从以下方面来说明其内涵:
/ o! u- v% v  X5 t1 j) o
  • 从用户角度:目标驱动,结果呈现。举例:用户一键指定目标进程,几秒后系统告知哪些线程CPU高对应代码是哪些
  • 从流程角度:覆盖全流程,包括诊断数据捕获,归集,存储,查询和分析
  • 从数据角度:诊断数据统一集中管理,随时随地可查
  • 从工作模式:从人工被动转变为触发式或主动式或联动式(后面会提到)
  • 从体验角度:人人通过系统,都能实现移动化运维,不再受专业工具的束缚
    / w' Q7 a& _$ I

3 z" }6 f3 N. I( x* F! F  s8 x

一键式线程分析的实现原理


! H' @$ `0 V' K% v* m, u1 E4 v  `3 F
接下来,我们进入本次分享的重点,剖析一下一键式线程分析的实现原理。本文以JVM的一键式线程分析来说明实现原理。

  n# p. ?) n) @* E0 _
它包含5个基本环节:

  M" S/ a+ m* ~0 b
  • 捕获:收集线程相关的原始诊断数据
  • 归集:将数据从目标机器传输到服务端的过程
  • 分析:基础分析和深度分析
  • 存储:将分析结果存储的过程
  • 查询:提供查询接口,支持灵活的查询
    # c$ o, |/ ^* ?: B# w
4 N( B' j% z) L8 d
下图是一个参考实现架构,它说明这5个环节的工作关联:
0?wx_fmt=png.jpg
! ~) e- [2 u2 P9 O# ~, F
  • 捕获通过对目标进程的采集,将采集结果生成Dump(内存或文件皆可能)
  • 归集客户端将Dump封装成消息,发送到消息队列
  • 归集服务端从消息队列取出该消息,并提取Dump数据
  • 基础分析对Dump数据进行分析转换成存储数据
  • 存储环节实现数据存储,这个部分推荐使用Elastic Search,后面会说明选型的原因
  • 查询提供对Dump数据的多维度检索,是深度分析的基础
  • 深度分析是将Dump数据真正实现自动化问题诊断的步骤,后面的应用场景剖析会重点说明
    ( L4 J( k! }* X9 A/ h2 f

' T6 ?3 C" ]' b- C; C. f捕获实现3 v* c0 o4 B' k" `
首先需要确定要捕获的内容:
, F6 R5 V7 C$ _9 ^
  • 目标进程的资源消耗:CPU,内存等,Linux系统可通过top获得
  • 目标进程的线程资源消耗:通常Linux系统通过top -Hp <pid>获得
  • JVM的线程Dump:Java中可以通过jstack或jdk自带API来获得
  • 目标进程的业务元数据:可以实现业务关联,例如应用名称,属于业务线,这些数据有助于业务层面实现关联性
    ( X( R; e, x$ H. f- F' ]  C
' \! I5 d0 c* y& I* m2 O, w
要实现对以上数据的捕获通常有两种方式。
" F7 T0 O  O& c0 ~; ]  ^2 Y) n
方式一:捕获直接触发Dump生成
0?wx_fmt=png.jpg
( z8 O+ }" K& t' D
[1]通过top命令获得进程性能
[2]通过top -Hp <pid>获得线程性能
[3]通过jstack <pid>生成Java Thread Dump

: k$ d7 w: k0 U7 P. E5 N, I
  • 优点:结构简单,易于实现
  • 限制:采集程序与目标进程必须相同用户启动。这是因为由于操作系统限制,不同用户的进程状态信息互不可见。
    0 h; |5 m, |) {1 T1 {0 x* X! z

& l) W+ c: u! p5 _- ^, n
方式二:捕获间接触发Dump生成
0?wx_fmt=png.jpg
2 l5 q& C* u/ Z; J
[1]在目标JVM增一个代理,该代理可以接受远程请求从而触发以下动作
[2]通过top命令获得进程性能
[3]通过top -Hp <pid>获得线程性能
[4]通过jstack <pid>生成Java Thread Dump

( b& l  |" f5 h- Q; x
  • 优点:采集程序与目标JVM可以是不同用户,采用了远程通信的方式来触发。对容器友好(Docker等),可以通过容器暴露的端口来进行采集。在与应用共享JVM,可以提取一些应用业务特征,例如应用名称。
  • 限制:尽管概率较小,在目标JVM完全hang死时,将无法捕获Dump

    2 A) t8 c+ |( ]9 z# [0 N

% v/ B' D+ {4 D( B" x' @3 a6 E$ K2 a
在实际应用中,我们使用的是第二种方式,供大家参考。
; s' ~$ t- ]/ }* S1 F' T) L, v
这种方式需要实现一个代理,它需要负责接受触发指令和触发Dump数据生成。实现代理有以下方式:

" m3 H1 N& |' s0 p" B) {0 P  j* K7 j; Y
方法一:应用级别增加一个新的Servlet或Filter

) ~& F& L" Q; Y# q
优点:实现简单

- |' S* h0 r% m: V
缺点:与应用绑定,生命周期的管理需应用参与;与应用隔离弱,可能互相干扰
* V5 j7 t1 R  z
方法二:如果是JEE应用服务器,可实现一个全局Filter或Listener,类似Tomcat,Jetty等都支持类似功能

. ^6 _8 F( V/ Y. _. p
优点:与应用解耦,实现也比较简单

4 p. L' i1 X* H% m) o
缺点:非JEE应用服务器场景不支持
7 V) ]9 Z/ Z) X
方法三:实现一个内置服务(推荐)
# f" d* M, d& v5 h9 D
这是一种参考实现:基于com.sun.net.httpserver.HttpServer实现Http服务,这是JDK自带的功能,无需外部依赖;使用javaagent机制,在程序启动时,启动Http服务,如图:
0?wx_fmt=png.jpg
- i1 o3 h( E! e8 w- }3 }3 Y9 s# ~
优点:
  • 实现比较简单,并没有引入第三方技术栈,都是JDK原生的
  • 部署简单,与应用无关,只是追加-javaagent参数即可
  • 对应用本身无侵入,无论是否是JEE应用服务器都可用
  • 可以增加一些无需停机或静态配置的管理特性,例如:指定/改变dump目录存放位置
    ( U( R  B$ n8 p5 Q4 b7 A6 N
1 U5 C) f0 ]/ i1 u- u
接下来要考虑应该采用什么方式来输出Dump数据,通常是将Dump数据输出成文件。通常有两种方式:
: E2 H& f& ~- B  L9 P' b' Y+ W5 f& c
方法一:原始方式,至少3个文件:进程性能,线程性能,线程Dump
. D- F* |5 X( y6 q
优点:无需任何处理,实现简单
缺点:
  • 不便统一归集,要保证3个文件被同时归集
  • 不便这些临时文件的管理
  • 如果执行中有异常而中断,产生碎片文件

    6 |3 J: I2 V7 o. I
7 D+ q* r$ n$ G$ i/ O, ?3 B
方法二(推荐):合并为一个文件(格式布局参见下图)
0?wx_fmt=png.jpg
5 x  L/ F8 I* f. y7 p. U* X% g
3 `/ N6 T$ D$ {8 ?$ g$ m
这个文件的命名可以是:<ip>_<端口或工作目录>_<时间戳>,这样可以识别是哪个机器上的哪个进程,什么时间产生的。另外,不使用pid的原因是重启后pid会变,但其实还是那个程序(程序特征不变)。

5 m: ?$ Z# J5 _
优点:
  • 一次归集即可
  • 临时文件管理简单,自动刷掉前一次
  • 没有碎片文件,如果中断后再来一次,自动刷掉前一次

    2 N1 @6 v/ n9 p3 ~. `& {
! E: m; R/ w) Q5 q9 s0 R  O6 K
归集实现! l: ]  {- j. I  n0 Q6 |/ I
在完成捕获以后,接下来就是实现归集,归集的实现本质就是消息发送(归集客户端)和消息消费(归集服务端)。
$ {. r. l* B1 \- X& Q: C7 N
我们使用RocketMQ来完成这项工作:

& j2 t  a1 {; d3 m8 U' _6 r2 p( Q8 E
  • 捕获程序完成捕获(成功生成Dump文件),通知归集客户端Dump文件的路径
  • 归集客户端对该路径Dump文件启动归集,一次性读取文件
  • 将读取的Dump文件转换成消息格式,并进行压缩(GZip),发送到消息队列
  • 归集服务端从消息队列读取消息,并解压缩
  • 从消息中提取Dump的数据,为基本分析做准备
    ! d0 T7 h; N9 K# h$ k/ P

3 c. U& |/ m6 \" x
0?wx_fmt=png.jpg

" J# Q4 O0 \' N5 a$ _
实现归集,需要注意两个方面的问题:

. D# ~& ^0 L# k6 O' ]1 y
1、尽量使用同一个消息封装一次捕获的数据,避免时序问题。下图是一种归集消息的schema参考实现
' h: J3 c* }! o; j
0?wx_fmt=png.jpg

% C2 z1 M+ }: y* n# M& i# P
2、如果确实很大(压缩后依然很大),则拆分的多个消息要保持时序。这里提供一种参考实现:

+ W: e9 g) S& z9 \- `
  • 给每个消息加个唯一有序编号和序列长度
  • 任何一个归集消费者获取到消息时,先缓存消息
  • 然后检查缓存消息是否达到序列长度
  • 如果未达成,则不处理
  • 如果达成,则进行基本分析
  • 基本分析完成后,清理缓存
    / |. q0 G6 U( _. F$ y

9 h0 Y1 x# h0 M* o基本分析- i" b" V& H( c
归集完成后,接下是基本分析的步骤。它就是对Dump文件进行解析,提取各个区段的数据,并转换成存储所需的格式。下图是提取的映射关系。

& E5 \+ p7 a/ i9 ~) G( G
0?wx_fmt=png.jpg
  Q5 l  J& ?1 ^
存储实现) b$ N  G5 A9 U
基本分析完成后,就要将数据存储起来。推荐使用Elastic Search(简称ES)来实现,这样做的原因是:
# v1 T- X! c: `. h$ b# a3 F. v7 J
  • 从查询角度考虑,高效的搜索,分词支持
  • 从深度分析角度考虑,易于对接其他大数据工具,易于时序化
  • 从存储角度,实现多索引/Mapping管理,易于清理和合并

      F/ ?  V6 z' I: x/ t2 i9 S0 B: M

* d; K" N8 p& X; o
使用ES来存储,要考虑线程Dump索引的管理模式,这里提供一种参考方法:

: N3 C, b6 [8 s: `& d$ F$ u
  • 全部线程Dump信息在一定周期内使用同一个索引,比如1周
  • 索引命名:jta_<某周的第一天>,判断当前是属于那个周的索引,命名是以周日开头的那天日期
  • 每隔一个自然周(7天)自动建立一个全局的新索引,让数据自动流入这个新的索引
    例如:2017-06-24的数据实际是在2017-06-18(周日)的索引里面,实际索引是jta_2017-06-18
  • 当然增加一个统一别名也可以

    7 N+ m: M; f! N' o  G: A8 V/ ?
2 V9 t; Q0 Z/ i
为什么要采用这样的索引管理,是因为:

  K8 B" R/ p+ q; e
  • ES中一个index不宜过大,同时单index查询效率高于跨index查询,多数情况下,线程Dump的查询在时间维度很集中
  • 每隔7天自动切分一个新索引,从数据清除的角度,ES的index是整块清除,粒度大小合适,比按Document的逐条清除的代价小,且不同索引之间干扰较小

    . y& d% N) ^' A9 _+ D
: C3 u& q& H; r! a
那么如何实现自动的索引切分呢?在要插入数据之前,获取当前应该使用的索引,根据当前日期判断属于哪一周,从而获得当周的周日日期。之后,判断索引是否创建,如果没有创建,就创建索引并完成Mapping工作,然后将数据插入ES。

7 {4 A  J) A" _* M" U
下图是ES索引Mapping的参考实现

% v! }& q% d! d; ~
0?wx_fmt=png.jpg

1 }- F, X: w# i7 `8 |查询实现* v8 g) [+ Z3 `. b! x
存储完成后,我们已经可以初步来使用线程Dump数据了。实现查询通常有两种方式:
0 L: c' V+ k2 ~& Y1 y) Q
方式一:直接使用ES的DSL
9 s9 F- S" e( o2 U! p8 f! k
  • 适用场景:与支持ES的数据分析软件集成,比如Kibana或Grafana
  • 优点:无需二次开发,可以十分灵活的查询
  • 缺点:调用方需要完全了解存储schema以及DSL语法;返回结果包含一些不会使用ES元数据

    5 T3 n9 ^' B( d( K8 }1 w% M

! s3 k  F- c" i1 C6 S7 c! \
方式二:实现查询服务
/ V! s0 @) R6 Z
  • 适用场景:系统对接
  • 优点:包含业务场景,简化调用方式;可以提供通用的查询模板,深度分析的开发可以简化
  • 缺点:需要二次开发
    . ]( N) ^! P5 M8 G: R9 l5 B5 n# C  t

& C1 X  r/ X, N) _# P* \+ J/ ^
为了实现深度分析,我们在实际应用中实现了查询服务。
; S; a% c- Q4 c7 e
深度分析9 u- M+ i/ H/ L
接下来谈谈深度分析的实现。

6 O& _; _5 B* O/ N& Y
如果有读者对于Java的线程Dump知识还不太熟悉,可以搜索一下这方面的内容,网上的解读很多。这里只着重强调一下关于线程等待的关键字,因为线程等待是我们经常遇到的问题,而从等待状态入手做线程分析是常用手段。Java的线程等待状态有两种关键字:
- K; r' M: C- {4 G
  • Wait on condition:等待资源,或等待某个条件的发生;程序代码读取某种资源;等待其他线程执行;等待网络I/O;主动Sleep
  • Waiting for Monitor Entry / in Object.wait():每个对象有且仅有一个Monitor,可被看成对象/Class锁。这时线程会有两种表现:

    3 ~# Y: {8 B) i6 `5 L% K
  • Active Thread:同一时刻,只能一个线程持有Monitor
  • Waiting Thread:处于Entry Set=Waiting for Monitor Entry;处于Wait Set=Object.wait()
    ! ~% u2 L) q  _! l/ Q
3 [8 P' B6 W; W
首先,说明一下深度分析的目标:
  • 将SRE的线程分析经验按照场景实现成分析模板
  • 线程分析按某个维度的数据聚类
  • 实现与其他APM数据之间的关联
    + W& z: k( j' Z; u4 N
& Y  i  S' o) B/ e! c
下面会重点说明一下分析模板的实现思路。
) Y3 [7 q' s5 l3 p& h
分析模板是根据问题诊断的目标场景建立的分析过程模型,它具备良好的通用性,只与目标场景有关,它的实现方式通常是一个算法。特别注意:这些算法与目标场景可以是一对多的关系。

, E) ]+ |  M( Q5 n5 s* ^
分析模板实现分析的步骤:
  • 确定分析目标
  • 根据经验,确定分析目标达成的步骤以及数据关联
  • 确认分析模板的算法实现
  • 通过查询来提取分析目标所需的原始数据
  • 输入原始数据,执行分析步骤,获得分析

    3 n0 R6 J7 O/ y- f6 \3 _) ~
; G  D, Q  C$ V+ t5 x
下图是深度分析中实现分析模板处理的一种参考实现。
' E& M6 L/ L* p  G4 x1 p3 V
0?wx_fmt=png.jpg

: N# l0 k& T) i6 Z6 p# a
  • 筛选:根据场景,确定候选的线程Dump数据
  • 分析目标匹配:根据输入意图,读取分析模板配置,匹配可能的分析模板
  • 分析模板加载:根据配置,加载分析模板,分析模板的实现可以是一个jar包或其他可加载代码
  • 分析模板运行:通过分析模板处理获得分析结果
  • 分析结果输出:将分析结果以某种格式输出,用于可视化展示或提供给其他系统使用
    ' i5 q# r& X, Y+ t  `+ A" B* y% ~
1 o* m; T: ?! y5 o; b  y4 G

应用场景解析


3 \' Z5 R" d, Y. w/ r5 q+ T& ?  F& H( C
这个部分会就深度分析的一些典型场景进行剖析,来说明如何实现分析模板以及如何应用。
% r8 d4 o4 J' m  e* n; B
场景一:高CPU分析1 B. O) ], ~% i
这是一个经常遇到的场景。它的分析模板如下:
& y8 P$ y: w$ x$ i$ A% Y3 Q
  • 使用PID提取一次捕获的所有State为Runnable线程Dump数据
  • 按CPU字段降序排列

    / u0 p  C+ I) Q: D; G  C
, y8 X0 Z9 w1 {7 x
通过这个分析模板可以如下效果:
) O: h2 Y' R) {+ Z/ {* r* x( b2 d
0?wx_fmt=png.jpg
7 I  [! C: ]7 p. i4 n9 A& s; i
当然,这个基础上可以扩展分析模板做一些后续处理:
; D% z: o$ ]3 _) e8 {+ m5 N
  • 识别线程类型:GC线程/RMI线程/中间件线程/用户线程池等
  • 根据高CPU的线程类型,实现根源分析提示:

    " [7 U) _1 c1 m9 R1 S
1)GC类线程:GC过于频繁
2)中间件线程/用户线程池:如果是用户代码,则可能是代码有高计算处理
3)RMI或通信类线程:则可能是网络流量大或达到瓶颈

6 W4 ~) ?/ V# \9 l0 m3 q场景二:死锁分析+ j7 q. C7 ?# U) z1 K
死锁也是比较典型的线程问题。实际上Java的线程Dump自带了Dead Lock的分析结果,所以如果希望直接知道结果,通过查询Dump数据的Dead Lock即可。
: q" n& ~- J7 R6 |9 ?
这里要介绍另一种方法,基于锁依赖的有向图。它期望通过对线程锁的互相依赖来实现更加全面的根因分析。
, }  P" Q, `  R( v) w) E0 q
在死锁这个场景里,是这样实现的:
+ Q4 N" E  |1 B/ d3 c  i
  • 使用PID提取一次捕获的所有线程Dump数据
  • 构造基于锁依赖的有向图,每个线程是一个节点,它对其他线程的锁依赖是一条有向连线
  • 构造完成后,根据标记的环,获得所有的死锁环路
  • 提取每个死锁环路中的关键线索
    1)每个线程的持有对象ID以及类型:持有对象类型可以辅助死锁的业务分析
    2)每个线程等待的对象ID以及类型:等待对象类型可以帮助定位死锁的业务语义
    3)每个线程Stack中的线程栈方法:方法对应处理逻辑,通常是问题根源所在
    5 K& e$ {8 k# O& y! w

2 Q$ P2 K. t' F7 ?* j, N+ D
死锁的锁依赖的有向图的算法过程如下:
: y0 Y+ @8 J4 |& b! w
  • 遍历每个线程的Dump数据
  • 如果State是非等待状态,则检查节点是否已经存在,若不存在,则增加一个图的节点
  • 如果State是等待状态,则检查节点是否已经存在,若不存在,则增加一个图的节点
    1)然后提取ThreadInfo(包含thread stack)包含wait to lock <XXX>, XXX为对象ID
    2)查找包含locked <XXX>的那个线程,也增加一个图的节点(如果存在就不增加),画一条有向连线指向该节点
    3)查找所有包含wait to lock <XXX>的线程,每找到一个也增加一个图的节点(如果存在就不增加),并画一条有向连线指向locked <XXX>的线程节点

    ' @% _! F/ L; f8 J7 h$ |" w- u
# x% j7 }: k, F+ d
通过锁依赖的有向图可以观察到四种基本死锁(如下图)
. s2 C' U& O: k* R; V4 g6 w4 V5 D/ }& ^
0?wx_fmt=png.jpg

4 G/ a/ f9 W4 c
  • 互等死锁:两个线程互相等待同一个锁
  • 传递死锁:多个线程之间互相等待一个或多个锁,构成环状
  • 混合死锁:由上面两种死锁造成对其他线程的影响,所以它可以反应死锁影响的范围
    ' ~# A4 C) p8 p* m6 f" E" u
1)形式一:某些线程依赖于互等死锁的线程持有的锁
2)形式二:某些线程依赖于传递死锁的线程持有的锁

' v3 h/ x( u! N* x" a) g% P场景三:单线程等待分析: Z  W) D/ p/ U- D0 x- s2 B
单线程的等待分析也是经常使用的手段。它的分析模板如下:

- @# z9 [, {1 K( Z; D3 W
  • 提取该线程Dump数据(State应该为Blocked,in Object.wait等等待状态)
  • 提取wait to lock <XXX>, 获得XXX(对象ID)
  • 查找locked <XXX>的线程Dump数据
  • 检查其状态

    ! Z( h7 z0 m- P4 n5 S5 \" y; R: w
1)如果是非等待状态,那么说明线程在运行
2)如果是等待状态,则提取wait to lock <YYY>,获得YYY(对象ID)
3)查找locked <YYY>的线程Dump数据,以此类推
  • 同时在过程中提取线程的关键线索
    + Y! z/ e/ I* g$ R. o& n0 F" T+ Q- y
1)每个线程的持有对象ID以及类型
2)每个线程等待的对象ID以及类型
3)每个线程Stack中的线程栈方法
: f6 I  l) d% Y; G
其实可以发现这也是一个基于锁依赖的有向图,只是只有一条有向路径而已。
, d( ^/ X/ S% ^$ Q7 l' {/ W+ e0 m' m
场景四:单线程的工作状态分析3 I+ [" {1 j/ C6 U7 v' S
当然可能我们不仅仅只关注等待状态。有时候我们需要对线程的全部状态进行分析。对单线程而言,它的分析模板:
" @. g1 J. M1 e  w& z
  • 连续提取N次捕获的某线程Dump数据(是一个有时序的列表)
  • 遍历每次的线程Dump数据,并构造该线程每次捕获的基于锁依赖的有向图
  • 将所有有向图按时序叠加,获得一个时序有向图

    . e; @8 P2 L( Q1 r& d

2 M/ L$ k+ F3 M
这个时序有向图可以帮助发现以下内容:
  • 可看到某个线程在某个时间范围的线程状态变化
  • 可以直观的获得线程等待状态的根源,比如死锁

    ! o) P! Q- a  o6 q# p6 s, o

6 K% f% n/ j% y' y5 M" b
下图是一个例子:线程A在10:35处于运行状态(绿色),而10:45时A处于等待(橙色),A在等待B持有的锁,到10:55,A仍然处于等待,这时候发现B和C形成了互等死锁,A与B,C形成了混合死锁,这就是A仍然处于等待的原因。
0?wx_fmt=png.jpg
  h0 b, j$ G' {# @) X
场景五:多线程的工作状态分析; ?9 G2 c7 `! J3 u1 K
在单线程的基础上,我们把问题扩展到多线程。它的分析模板:

( r, r3 @& i) U  y- |7 w
  • 连续提取N次捕获的符合某种过滤条件的线程Dump数据
  • 遍历每次的每个线程Dump数据,并构造该线程每次捕获的基于锁依赖的有向图,将该线程的所有有向图按时序叠加,获得一个时序有向图
  • 将所有时序有向图叠加,就获得了多线程的时序有向图
    # c5 {' b1 Y- j% l8 P& P
" m! L2 A9 F" C* Y8 K8 J4 ^1 |5 c
通过这样的分析模板,可以获得全部线程的时序有向图。看下面的例子:10:35时,A、B都是运行态,C处于等待B的某个锁;10:45时,A结束运行等待B的某个锁,B结束运行处于等待,C运行,而此时B等待C的某个锁;10:55时,A依然等待B,B等待C,而C结束运行,等待B,由于此时B和C死锁,造成A也“被”死锁。

* P& H. g3 F$ x6 y2 d
0?wx_fmt=png.jpg
0 s: u8 C5 O/ `) |$ L  w

总结

- ?* M0 x$ C  d5 w; i7 M+ `
下面来总结一下本次分享的内容:
: R+ V! o( @2 ]1 [/ B8 X3 r
  • 第一部分:描述了自动化运维中APM的内容是什么,说明两个关键问题:实时监控和问题诊断,而问题诊断又面临了哪些挑战,列举了APM工具箱包含的内容,其中线程诊断分析尤其重要
  • 第二部分:通过一个经典线程分析问题,说明传统手段的痛点,也结合自动化运维以及数据深度的要求来阐述为什么需要一键式线程分析,并从多个角度来说明什么是一键式线程分析
  • 第三部分:剖析一键式线程分析的基本架构,分别从其5个关键步骤(捕获,归集,存储,查询,分析)剖析实现原理
  • 第四部分:从深度分析的应用场景出发,分别对高CPU,死锁,单线程分析,多线程分析进行分析模板的说明和应用
    % D; x1 v2 g) @/ C. u# Z. m
" x) d  Q3 ?- d
原创:张真

) ]/ _# v5 |: Q- @& ~# |

本版积分规则

选择云运维时代的王牌讲师-长河老师,助你轻松入门ITIL Foundation培训课程

QQ|小黑屋|手机版|Archiver|艾拓先锋网 ( 粤ICP备11099876号-1|网站地图

Baidu

GMT+8, 2019-2-16 03:43 , Processed in 0.210724 second(s), 31 queries .

Powered by Discuz! X3.2

© 2001-2013 Comsenz Inc.

快速回复 返回顶部 返回列表