Java: 线上故障如何快速排查？来看这套技巧大全(高德地图的总结)

Dear 丶 2022-10-16 15:22 483阅读 0赞

**目录**

前言

一 服务器层面

1.1 磁盘

1.1.1 问题现象

1.1.2 排查思路

1.1.3 相关命令

1.2 CPU 过高

1.2.1 问题现象

1.2.2 排查思路

1.2.3 相关命令

二 应用层面

2.1 Tomcat 假死案例分析

2.1.1 发现问题

2.2.2 查询日志

2.2.3 获取内存快照

2.2.4 分析内存快照文件

2.2.5 相关知识

2.2 应用 CPU 过高

2.2.1 发现问题

2.2.2 查找问题进程

2.2.3 查找问题线程

2.2.4 查询线程详细信息

2.2.5 分析代码

2.2.6 获得结论

三 Mysql

3.1 死锁

3.1.1 问题出现

3.1.2 问题分析

3.2 慢 SQL

3.1.1 问题出现

3.1.2 问题分析

3.1.3 场景一

3.1.4 场景二

3.3 连接数过多

3.3.1 问题出现

3.3.2 解决方案

3.4 相关知识

3.4.1 索引

3.4.2 B+ Tree 索引检索

3.4.3 事物的隔离级别

3.4.4 Innodb 的多种锁

3.4.5 线上问题处理

3.5 一些建议

3.5.1 小表驱动大表

（2）大表驱动小表

3.5.2 使用自增长主键

四 Redis

4.1 问题处理思路

4.2 内存告警

4.2.1 设置合理的内存大小

4.2.2 设置合理的内存淘汰策略

4.2.3 查看大 key

4.3 Redis 的慢命令

4.3.1 设置 Redis 的慢命令的时间阈值(单位：微妙)

4.3.2 查看 Redis 的慢命令

4.4 连接过多

4.5 线上 Redis 节点挂掉一个之后的处理流程

4.5.1 查看节点状态

4.5.2 移除错误节点

4.5.3 恢复节点

五 网络

5.1 排查流程

5.1.1 现象出现

5.1.2 查看是否遭受了 DOS 攻击

5.1.3 查看 TCP 连接状态

5.2 相关知识

5.2.1 TCP 连接

5.2.2 一些常见问题

六 业务异常日志

6.1 问题出现

6.2 日志分析

6.2.1 确认日志格式

6.2.2 在日志文件中检索异常

6.2.3 代码分析

--------------------

# 前言 #

线上定位问题时，主要靠监控和日志。一旦超出监控的范围，则排查思路很重要，按照流程化的思路来定位问题，能够让我们在定位问题时从容、淡定，快速的定位到线上的问题。

![f02e0f5bf6da18764f7c77575a0439b1.png][] 线上问题定位思维导图

# 一 服务器层面 #

## 1.1 磁盘 ##

### 1.1.1 问题现象 ###

当磁盘容量不足的时候，应用时常会抛出如下的异常信息：

java.io.IOException: 磁盘空间不足

或是类似如下告警信息：

![86c44dc142aaa4c4add207f6c9b47d11.png][]

## 1.1.2 排查思路 ##

**1.1.2.1 利用 df 查询磁盘状态**

利用以下指令获取磁盘状态：

df -h

结果是：

![9f189c2f00c101bb5dc8bc2719bde831.png][]

> 可知 / 路径下占用量最大。

**1.1.2.2 利用 du 查看文件夹大小**

> 利用以下指令获取目录下文件夹大小：

du -sh *

结果是：

![e34c720df1fbe58ae31ecf1f7baba299.png][]

> 可知 root 文件夹占用空间最大，然后层层递推找到对应的最大的一个或数个文件夹。

**1.1.2.3 利用 ls 查看文件大小**

利用以下指令获取目录下文件夹大小：

ls -lh

结果是：

![afbf2f48f66032ca80a1d6209130476a.png][]

> 可以找到最大的文件是日志文件，然后使用 rm 指令进行移除以释放磁盘。

### 1.1.3 相关命令 ###

**1.1.3.1 df**

> 主要是用于显示目前在 Linux 系统上的文件系统磁盘使用情况统计。

**（1）常用参数**

**启动参数：**

![7db83b725a25d0fa5a9e95dabb6b0c21.png][]

（2）结果参数

![1bb58904c9eb77c47c767d3219b06a63.png][]

![2e16c5c2f33840dd0fa63c66ce5ca181.png][]

**1.1.3.2 du**

> 主要是为了显示目录或文件的大小。

**（1）常用参数**

**启动参数：**

![1d08b77eb79b472823c4900e3d9d10a9.png][]

**（2）结果参数**

![9a8372f89b8ab937ac80a9338f14f974.png][]

**1.1.3.3 ls**

> 主要是用于显示指定工作目录下的内容的信息。

（1）常用参数

启动参数：

![77f12ad5269fcc031d3418aef56cf80b.png][]

**（2）结果参数**

![36a9349876c40a6b16513cb0e707d229.png][]

## 1.2 CPU 过高 ##

### 1.2.1 问题现象 ###

> 当 CPU 过高的时候，接口性能会快速下降，同时监控也会开始报警。

### 1.2.2 排查思路 ###

**1.2.2.1 利用 top 查询 CPU 使用率最高的进程**

**利用以下指令获取系统 CPU 使用率信息：**

top

结果是：

![d8e3357b5545015f7690ab2e8686e8a1.png][]

> 从而可以得知 pid 为 14201 的进程使用 CPU 最高。

### 1.2.3 相关命令 ###

**1.2.3.1 top**

（1）常用参数

启动参数：

![06f1c33152cdb73764d4a91fc6fb4767.png][]

top 进程内指令参数：

![7710a2eb27f4e682a9ea60830290c198.png][]

（2）结果参数

![60f4e818622236923c9d8404d3a38df5.png][]

![e37fac8c245d8c36a180d68e5b734387.png][]

# 二 应用层面 #

## 2.1 Tomcat 假死案例分析 ##

## 2.1.1 发现问题 ##

> 监控平台发现某个 Tomcat 节点已经无法采集到数据，连上服务器查看服务器进程还在，netstat -anop|grep 8001 端口也有监听，查看日志打印时断时续。

![bec1cb2200d238b8f2fb33d1c4d2f510.png][]

## 2.2.2 查询日志 ##

> 查看 NG 日志，发现有数据进入到当前服务器（有 8001 和 8002 两个 Tomcat），NG 显示 8002 节点访问正常，8001 节点有 404 错误打印，说明 Tomcat 已经处于假死状态，这个 Tomcat 已经不能正常工作了。

过滤 Tomcat 节点的日志，发现有 OOM 的异常,但是重启后，有时候 Tomcat 挂掉后，又不会打印如下 OOM 的异常：

TopicNewController.getTopicSoftList() error="Java heap space
    From class java.lang.OutOfMemoryError"appstore_apitomcat

### 2.2.3 获取内存快照 ###

> 在一次 OOM 发生后立刻抓取内存快照,需要执行命令的用户与 JAVA 进程启动用户是同一个，否则会有异常：

/data/program/jdk/bin/jmap -dump:live,format=b,file=/home/www/jmaplogs/jmap-8001-2.bin 18760
    
    ps -ef|grep store.cn.xml|grep -v grep|awk '{print $2}'|xargs /data/program/jdk-1.8.0_11/bin/jmap -dump:live,format=b,file=api.bin

> **内存 dump 文件比较大，有 1.4G，先压缩，然后拉取到本地用 7ZIP 解压。**
> 
> **linux 压缩 dump 为.tgz。**

在 windows 下用 7zip 需要经过 2 步解压：

.bin.tgz---.bin.tar--.bin

### 2.2.4 分析内存快照文件 ###

> 使用 Memory Analyzer 解析 dump 文件，发现有很明显的内存泄漏提示。

![b462208175ac4469dbf1026825cf4969.png][]

> 点击查看详情，发现定位到了代码的具体某行，一目了然：

![f75f3281493e4608312c4a32231d08a2.png][]

查看 shallow heap 与 retained heap 能发现生成了大量的 Object(810325 个对象)，后面分析代码发现是上报 softItem 对象超过 300 多万个对象，在循环的时候，所有的数据全部保存在某个方法中无法释放，导致内存堆积到 1.5G，从而超过了 JVM 分配的最大数，从而出现 OOM。

![c06908a0558746e729c704dbe44a61c5.png][]

java.lang.Object[810325] @ 0xb0e971e0

![e2c74ccb5aea07f88cf56266abe0ca72.png][]

### 2.2.5 相关知识 ###

**2.2.5.1 JVM 内存**

![e62f95212477ce8f53171de4bb0bd3e2.png][]

**2.2.5.2 内存分配的流程**

![4eed9e66f3bc02811e69f5fcb0fdd01f.png][]

> 如果通过**逃逸分析**，则会先在 TLAB 分配，如果不满足条件才在 Eden 上分配。

**2.2.4.3 GC**

![206154cdc0fa345ef47713140a3fbc60.png][]

**（1）GC 触发的场景**

![1bc0187b86f0689dcc297a1123654d72.png][]

**（2）GC Roots**

**GC Roots 有 4 种对象：**

>  *  虚拟机栈(栈桢中的本地变量表)中的引用的对象，就是平时所指的 java 对象，存放在堆中。
>  *  方法区中的类静态属性引用的对象，一般指被 static 修饰引用的对象，加载类的时候就加载到内存中。
>  *  方法区中的常量引用的对象。
>  *  本地方法栈中 JNI（native 方法)引用的对象。

**（3）GC 算法**

![eb23efc7c5a1c3c4e8010f87287e7c72.png][]

>  *  串行只使用单条 GC 线程进行处理，而并行则使用多条。
>  *  多核情况下，并行一般更有执行效率，但是单核情况下，并行未必比串行更有效率。

![5c4f438d64ed3db8da9ddf08e66cad5e.png][]

>  *  STW 会暂停所有应用线程的执行，等待 GC 线程完成后再继续执行应用线程，从而会导致短时间内应用无响应。
>  *  Concurrent 会导致 GC 线程和应用线程并发执行，因此应用线程和 GC 线程互相抢用 CPU，从而会导致出现浮动垃圾，同时 GC 时间不可控。

**（4）新生代使用的 GC 算法**

![0ee879e017069538a28b82be79ade3a0.png][]

>  *  新生代算法都是基于 Coping 的，速度快。
>  *  Parallel Scavenge：吞吐量优先。
>  *  吞吐量=运行用户代码时间 /（运行用户代码时间 + 垃圾收集时间）

**（5）老年代使用的 GC 算法**

![40e4181d2770fca84bf0c2ed4ad1f606.png][]

![b22737d4755487b521a9e55dfed3ca47.png][]

**Parallel Compacting**

![a0ad2bf50a5a1b1f23c8507298516a86.png][] Concurrent Mark-Sweep(CMS)

**（6）垃圾收集器总结**

![87bc929c9e7c000ad0bf0c1267bd270f.png][]

**（7）实际场景中算法使用的组合**

![427fb81eb6a922519a846ef7473768f0.png][]

**（8）GC 日志格式**

**（a）监控内存的 OOM 场景**

> 不要在线上使用 jmap 手动抓取内存快照，其一系统 OOM 时手工触发已经来不及，另外在生成 dump 文件时会占用系统内存资源，导致系统崩溃。只需要在 JVM 启动参数中提取设置如下参数，一旦 OOM 触发会自动生成对应的文件，用 MAT 分析即可。

# 内存OOM时，自动生成dump文件-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/data/logs/
    如果 Young GC 比较频繁，5S 内有打印一条，或者有 Old GC 的打印，代表内存设置过小或者有内存泄漏，此时需要抓取内存快照进行分享。

**（b）Young Gc 日志**

2020-09-23T01:45:05.487+0800: 126221.918: [GC (Allocation Failure) 
    
    2020-09-23T01:45:05.487+0800: 126221.918:
     [ParNew: 1750755K->2896K(1922432K), 0.0409026 secs] 
    
    1867906K->120367K(4019584K), 0.0412358 secs] [Times: user=0.13 sys=0.01, real=0.04 secs]

![b1f3bc29f7bde46b48a2096d52463dbd.png][]

**（c）Old GC 日志**

2020-10-27T20:27:57.733+0800: 639877.297: [Full GC (Heap Inspection Initiated GC) 
    
    2020-10-27T20:27:57.733+0800: 639877.297: [CMS: 165992K->120406K(524288K), 0.7776748 secs] 329034K->120406K(1004928K), 
    
    [Metaspace: 178787K->178787K(1216512K)], 0.7787158 secs] [Times: user=0.71 sys=0.00, real=0.78 secs]

![3fb60fff5ff1be2637da9ffb302570d0.png][]

## 2.2 应用 CPU 过高 ##

### 2.2.1 发现问题 ###

一般情况下会有监控告警进行提示：

![9ebf33a07663cfc3a5b6d0b2287497b5.png][]

### 2.2.2 查找问题进程 ###

> 利用 top 查到占用 cpu 最高的进程 pid 为 14，结果图如下：

![06a17f1537b9a8d4bff7b20b8f12fcba.png][]

## 2.2.3 查找问题线程 ##

> 利用 top -H -p 查看进程内占用 cpu 最高线程，从下图可知，问题线程主要是 activeCpu Thread，其 pid 为 417。

![2d1b65131aa949489f5af8c4e34ad2ec.png][]

### 2.2.4 查询线程详细信息 ###

>  *  首先利用 printf "%x \\n" 将 tid 换为十六进制：xid。
>  *  再利用 jstack | grep nid=0x -A 10 查询线程信息(若进程无响应，则使用 jstack -f )，信息如下：

![657fd2e835504aba8f7d1a42684f33d9.png][]

### 2.2.5 分析代码 ###

> 由上一步可知该问题是由 CpuThread.java 类引发的，故查询项目代码，获得如下信息：

![e04b1a571cf20870b52ebb59c1809dd5.png][]

### 2.2.6 获得结论 ###

> 根据代码和日志分析，可知是由于限制值 max 太大，致使线程长时间循环执行，从而导致问题出现。

# 三 Mysql #

## 3.1 死锁 ##

## 3.1.1 问题出现 ##

> 最近线上随着流量变大，突然开始报如下异常，即发生了死锁问题：

Deadlock found when trying to get lock; try restarting transaction ;

### 3.1.2 问题分析 ###

3.1.2.1 查询事务隔离级别

> 利用 `select @@tx_isolation` 命令获取到数据库隔离级别信息：

![989343394d0a97a2d51425ae042db163.png][]

3.1.2.2 查询数据库死锁日志

> 利用 `show engine innodb status` 命令获取到如下死锁信息：

![dec296e005958617a9917f970625bb8e.png][]

![411f7c3b15ff4100c1cb62f5b8c52fff.png][]

> 由上可知，是由于两个事物对这条记录同时持有 S 锁(共享锁)的情况下，再次尝试获取该条记录的 X 锁(排它锁)，从而导致互相等待引发死锁。

3.1.2.3 分析代码

> 根据死锁日志的 SQL 语句，定位获取到如下伪代码逻辑：

@Transactional(rollbackFor = Exception.class)
    void saveOrUpdate(MeetingInfo info) {
        // insert ignore into table values (...)
        int result = mapper.insertIgnore(info);
        if (result>0) {
           return;
        }
        // update table set xx=xx where id = xx
        mapper.update(info);
    }

3.1.2.4 获得结论

> 分析获得产生问题的加锁时序如下，然后修改代码实现以解决该问题。

![5fbeb2d3a00d730f3a174281230288e5.png][]

## 3.2 慢 SQL ##

### 3.1.1 问题出现 ###

> 应用 TPS 下降，并出现 SQL 执行超时异常或者出现了类似如下的告警信息，则常常意味着出现了慢 SQL。

### 3.1.2 问题分析 ###

> 分析执行计划：利用 explain 指令获得该 SQL 语句的执行计划，根据该执行计划，可能有两种场景。

>  *  SQL 不走索引或扫描行数过多等致使执行时长过长。
>  *  SQL 没问题，只是因为事务并发导致等待锁，致使执行时长过长。

### 3.1.3 场景一 ###

3.1.3.1 优化 SQL

> 通过增加索引，调整 SQL 语句的方式优化执行时长， 例如下的执行计划：

![c7bbcae1307481f6d85e3b47f3a62b4a.png][]

该 SQL 的执行计划的 type 为 ALL，同时根据以下 type 语义，可知无索引的全表查询，故可为其检索列增加索引进而解决。

![c001963b3c86ee031b941e3a59d9e4ae.png][]

### 3.1.4 场景二 ###

3.1.4.1 查询当前事务情况

> 可以通过查看如下 3 张表做相应的处理：

-- 当前运行的所有事务
    select *  from information_schema.innodb_trx;
    -- 当前出现的锁
    SELECT * FROM information_schema.INNODB_LOCKS;
    -- 锁等待的对应关系
    select *  from information_schema.INNODB_LOCK_WAITS;

（1）查看当前的事务有哪些：

![ced3ac1463c86f49955d9698441d2a84.png][]

（2）查看事务锁类型索引的详细信息：

![eb87edb43d6de2745760221a0160b5cb.png][]

> lock\_table 字段能看到被锁的索引的表名，lock\_mode 可以看到锁类型是 X 锁,lock\_type 可以看到是行锁 record。

3.1.4.2 分析

> 根据事务情况，得到表信息，和相关的事务时序信息：

DROP TABLE IF EXISTS `emp`;
    CREATE TABLE `emp` (
    `id` int(11) NOT NULL AUTO_INCREMENT,
    `salary` int(10) DEFAULT NULL,
    `name` varchar(255) DEFAULT NULL,
    PRIMARY KEY (`id`),
    KEY `idx_name` (`name`(191)) USING BTREE
    ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4;

> A 事物锁住一条记录，不提交，B 事物需要更新此条记录，此时会阻塞，如下图是执行顺序：

![93c095c9a1a403de2dc70072a478d84a.png][]

3.1.4.3 解决方案

（1）修改方案

> 由前一步的结果,分析事务间加锁时序，例如可以通过 tx\_query 字段得知被阻塞的事务 SQL,trx\_state 得知事务状态等，找到对应代码逻辑，进行优化修改。

（2）临时修改方案

> trx\_mysql\_thread\_id 是对应的事务 sessionId，可以通过以下命令杀死长时间执行的事务，从而避免阻塞其他事务执行。

kill 105853

## 3.3 连接数过多 ##

### 3.3.1 问题出现 ###

> 常出现 too many connections 异常,数据库连接到达最大连接数。

### 3.3.2 解决方案 ###

解决方案：

>  *  通过 set global max\_connections=XXX 增大最大连接数。
>  *  先利用 show processlist 获取连接信息，然后利用 kill 杀死过多的连。

常用脚本如下：

排序数据库连接的数目
    mysql -h127.0.0.0.1 -uabc_test -pXXXXX -P3306 -A -e 'show processlist'| awk '{print $4}'|sort|uniq -c|sort -rn|head -10

### 3.4 相关知识 ###

## 3.4.1 索引 ##

3.4.1.1 MySql 不同的存储引擎

![c23a192978a4b92f685303f575ba5969.png][]

3.4.1.2 InnoDB B+Tree 索引实现

**主键索引(聚集索引)：**

>  *  叶子节点 data 域保存了完整的数据的地址。
>  *  主键与数据全部存储在一颗树上。
>  *  Root 节点常驻内存。
>  *  每个非叶子节点一个 innodb\_page\_size 大小,加速磁盘 IO。
>  *  磁盘的 I/O 要比内存慢几百倍，而磁盘慢的原因在于机械设备寻找磁道慢，因此采用磁盘预读，每次读取一个磁盘页（page:计算机管理存储器的逻辑块-通常为 4k）的整倍数。
>  *  如果没有主键,MySQL 默认生成隐含字段作为主键，这个字段长度为 6 个字节，类型为长整形。
>  *  辅助索引结构与主索引相同,但叶子节点 data 域保存的是主键指针。
>  *  InnoDB 以表空间 Tablespace(idb 文件)结构进行组织，每个 Tablespace 包含多个 Segment 段。
>  *  每个段(分为 2 种段：叶子节点 Segment&非叶子节点 Segment)，一个 Segment 段包含多个 Extent。
>  *  一个 Extent 占用 1M 空间包含 64 个 Page（每个 Page 16k），InnoDB B-Tree 一个逻辑节点就分配一个物理 Page，一个节点一次 IO 操作。
>  *  一个 Page 里包含很多有序数据 Row 行数据，Row 行数据中包含 Filed 属性数据等信息。

InnoDB 存储引擎中页的大小为 16KB，一般表的主键类型为 INT（占用 4 个字节）或 BIGINT（占用 8 个字节），指针类型也一般为 4 或 8 个字节，也就是说一个页（B+Tree 中的一个节点）中大概存储 16KB/(8B+8B)=1K 个键值（因为是估值，为方便计算，这里的 K 取值为\[10\]^3）。

也就是说一个深度为 3 的 B+Tree 索引可以维护 10^3 \* 10^3 \* 10^3 = 10 亿 条记录。

![9c1585718a7c8d06224ce4807a917366.png][]

每个索引的左指针都是比自己小的索引/节点，右指针是大于等于自己的索引/节点。

### 3.4.2 B+ Tree 索引检索 ###

3.4.2.1 主键索引检索

select * from table where id = 1

![1d886637fcd9568225c9712cf6a3209c.png][]

**3.4.2.2 辅助索引检索**

select * from table where name = 'a'

![4f7c31aee863d5b7fda05ecaac214679.png][]

### 3.4.3 事物的隔离级别 ###

3.4.3.1 如何查看数据库的事务隔离级别

> 使用如下命令可以查看事务的隔离级别：

show variables like 'tx_isolation';

阿里云上的 rds 的隔离级别是 read committed ，而不是原生 mysql 的“可重复读（repeatable-read）。

![17ed81a7d9051abd186d1609c4bf00a9.png][]

>  *  Repeatable read 不存在幻读的问题，RR 隔离级别保证对读取到的记录加锁 (记录锁)，同时保证对读取的范围加锁，新的满足查询条件的记录不能够插入 (间隙锁)，不存在幻读现象。
>  *  在 MYSQL 的事务引擎中，INNODB 是使用范围最广的。它默认的事务隔离级别是 REPEATABLE READ(可重复读），在标准的事务隔离级别定义下，REPEATABLE READ 是不能防止幻读产生的。INNODB 使用了 next-key locks 实现了防止幻读的发生。
>  *  在默认情况下，mysql 的事务隔离级别是可重复读，并且 innodb\_locks\_unsafe\_for\_binlog 参数为 OFF，这时默认采用 next-key locks。所谓 Next-Key Locks，就是 Record lock 和 gap lock 的结合，即除了锁住记录本身，还要再锁住索引之间的间隙。可以设置为 ON，则 RR 隔离级别时会出现幻读。

3.4.3.2 多版本并发控制 MVCC

> MySQL InnoDB 存储引擎，实现的是基于多版本的并发控制协议——MVCC (Multi-Version Concurrency Control) (注：与 MVCC 相对的，是基于锁的并发控制，Lock-Based Concurrency Control)。
> 
>  *  MVCC 最大的好处，相信也是耳熟能详：读不加锁，读写不冲突。在读多写少的 OLTP 应用中，读写不冲突是非常重要的，极大的增加了系统的并发性能。
> 
> 在 MVCC 并发控制中，读操作可以分成两类：快照读 (snapshot read)与当前读 (current read)。
> 
>  *  快照读：简单的 select 操作，属于快照读，不加锁。(当然，也有例外，下面会分析)。

select * from table where ?;

当前读：特殊的读操作，插入/更新/删除操作，属于当前读，需要加锁。

select * from table where ? lock in share mode;     加S锁 (共享锁)
    -- 下面的都是X锁 (排它锁)
    select * from table where ? for update;
    
    insert into table values (…);
    
    update table set ? where ?;
    
    delete from table where ?;

3.4.4.3 场景模拟

> 修改事务隔离级别的语句：

SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;
    -- READ UNCOMMITTED/READ COMMITTED/REPEATABLE READ/SERIALIZABLE

（1）脏读场景模拟

DROP TABLE IF EXISTS `employee`;
    CREATE TABLE `employee` (
      `id` int(11) NOT NULL,
      `name` varchar(50) NOT NULL,
      `salary` int(11) DEFAULT NULL,
      KEY `IDX_ID` (`id`) USING BTREE
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- Records of employee
    -- ----------------------------
    INSERT INTO `employee` VALUES ('10', '1s', '10');
    INSERT INTO `employee` VALUES ('20', '2s', '20');
    INSERT INTO `employee` VALUES ('30', '3s', '30');

![a69b5534a82ceb015401fc2faa37a6ae.png][] 脏读场景模拟

（2）不可重复读模拟

DROP TABLE IF EXISTS `employee`;
    CREATE TABLE `employee` (
      `id` int(11) NOT NULL,
      `name` varchar(50) NOT NULL,
      `salary` int(11) DEFAULT NULL,
      KEY `IDX_ID` (`id`) USING BTREE
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    
    -- ----------------------------
    -- Records of employee
    -- ----------------------------
    INSERT INTO `employee` VALUES ('10', '1s', '10');
    INSERT INTO `employee` VALUES ('20', '2s', '20');
    INSERT INTO `employee` VALUES ('30', '3s', '30');

> 不可重复读的重点是修改: 同样的条件, 你读取过的数据, 再次读取出来发现值不一样了。

![3702e8979ef96dd5981d4542f5335dfb.png][]

（3）幻读场景模拟

> 表结构与数据如下：id 不是主键，也不是唯一索引，只是一个普通索引，事务隔离级别设置的是 RR，可以模拟到 GAP 锁产生的场景。

DROP TABLE IF EXISTS `emp`;
    CREATE TABLE `emp` (
      `id` int(11) NOT NULL,
      `salary` int(11) DEFAULT NULL,
      KEY `IDX_ID` (`id`) USING BTREE
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- Records of emp
    -- ----------------------------
    INSERT INTO `emp` VALUES ('10', '10');
    INSERT INTO `emp` VALUES ('20', '20');
    INSERT INTO `emp` VALUES ('30', '30');

> 修改 id=20 的数据后，会在加多个锁：20 会被加 X 锁,\[10-20\],\[20-30\]之间会被加 GAP 锁。

![8e1c4e89f7cbc3cc6aa77ae9328d5b5c.png][]

幻读的重点在于新增或者删除 (数据条数变化)。同样的条件, 第 1 次和第 2 次读出来的记录数不一样。

在标准的事务隔离级别定义下，REPEATABLE READ 是不能防止幻读产生的。INNODB 使用了 2 种技术手段（MVCC AND GAP LOCK)实现了防止幻读的发生。

### 3.4.4 Innodb 的多种锁 ###

3.4.4.1 锁类型

![61f204fc522d8e3bd4511736c0cbad00.png][]

>  *  表锁的优势：开销小；加锁快；无死锁。
>  *  表锁的劣势：锁粒度大，发生锁冲突的概率高，并发处理能力低。
>  *  加锁的方式：自动加锁。查询操作（SELECT），会自动给涉及的所有表加读锁，更新操作（UPDATE、DELETE、INSERT），会自动给涉及的表加写锁。也可以显示加锁。
>  *  共享读锁：lock table tableName read
>  *  独占写锁：lock table tableName write
>  *  批量解锁：unlock tables

**3.4.4.2 行锁**

![6c035b2765c3edf5d504f02352e12652.png][]

> 只在 Repeatable read 和 Serializable 两种事务隔离级别下才会取得上面的锁。

3.4.4.3 意向锁

（1）场景

>  *  在 mysql 中有表锁，LOCK TABLE my\_tabl\_name READ; 用读锁锁表，会阻塞其他事务修改表数据。LOCK TABLE my\_table\_name WRITe; 用写锁锁表，会阻塞其他事务读和写。
>  *  Innodb 引擎又支持行锁，行锁分为共享锁，一个事务对一行的共享只读锁。排它锁，一个事务对一行的排他读写锁。
>  *  这两中类型的锁共存的问题考虑这个例子：
>  *  事务 A 锁住了表中的一行，让这一行只能读，不能写。之后，事务 B 申请整个表的写锁。如果事务 B 申请成功，那么理论上它就能修改表中的任意一行，这与 A 持有的行锁是冲突的。
>  *  数据库需要避免这种冲突，就是说要让 B 的申请被阻塞，直到 A 释放了行锁。

（2）问题

> 数据库要怎么判断这个冲突呢？

（3）答案

无意向锁的情况下:

>  *  step1：判断表是否已被其他事务用表锁锁表
>  *  step2：判断表中的每一行是否已被行锁锁住。

有意向锁的情况下:

>  *  step1：不变
>  *  step2：发现表上有意向共享锁，说明表中有些行被共享行锁锁住了，因此，事务 B 申请表的写锁会被阻塞。

（4）总结

在无意向锁的情况下，step2 需要遍历整个表,才能确认是否能拿到表锁。而在意向锁存在的情况下，事务 A 必须先申请表的意向共享锁，成功后再申请一行的行锁，不需要再遍历整个表，提升了效率。因此意向锁主要是为了实现多粒度锁机制（白话：为了表锁和行锁都能用）。

3.4.4.4 X/S 锁

![65b274ffd5d70d46e7cf2e3f1afdf5b7.png][]

3.4.4.5 一条 SQL 的加锁分析

-- select操作均不加锁，采用的是快照读，因此在下面的讨论中就忽略了
    SQL1：select * from t1 where id = 10;
    SQL2：delete from t1 where id = 10;

组合分为如下几种场景：

![2d954bc5130dcfcdeebfb1d741fda61a.png][]

（1）组合 7 的 GAP 锁详解读

Insert 操作，如 insert \[10,aa\]，首先会定位到\[6,c\]与\[10,b\]间，然后在插入前，会检查这个 GAP 是否已经被锁上，如果被锁上，则 Insert 不能插入记录。因此，通过第一遍的当前读，不仅将满足条件的记录锁上 (X 锁)，与组合三类似。同时还是增加 3 把 GAP 锁，将可能插入满足条件记录的 3 个 GAP 给锁上，保证后续的 Insert 不能插入新的 id=10 的记录，也就杜绝了同一事务的第二次当前读，出现幻象的情况。

既然防止幻读，需要靠 GAP 锁的保护，为什么组合五、组合六，也是 RR 隔离级别，却不需要加 GAP 锁呢？

GAP 锁的目的，是为了防止同一事务的两次当前读，出现幻读的情况。而组合五，id 是主键；组合六，id 是 unique 键，都能够保证唯一性。

一个等值查询，最多只能返回一条记录，而且新的相同取值的记录，一定不会在新插入进来，因此也就避免了 GAP 锁的使用。

（2）结论

>  *  Repeatable Read 隔离级别下，id 列上有一个非唯一索引，对应 SQL：delete from t1 where id = 10; 首先，通过 id 索引定位到第一条满足查询条件的记录，加记录上的 X 锁，加 GAP 上的 GAP 锁，然后加主键聚簇索引上的记录 X 锁，然后返回；然后读取下一条，重复进行。直至进行到第一条不满足条件的记录\[11,f\]，此时，不需要加记录 X 锁，但是仍旧需要加 GAP 锁，最后返回结束。
>  *  什么时候会取得 gap lock 或 nextkey lock 这和隔离级别有关,只在 REPEATABLE READ 或以上的隔离级别下的特定操作才会取得 gap lock 或 nextkey lock。

### 3.4.5 线上问题处理 ###

3.4.5.1 观察问题的几个常见库表

首先可以通过下属两个命令来查看 mysql 的相应的系统变量和状态变量。

# status代表当前系统的运行状态，只能查看，不能修改
    show status like '%abc%';
    show variables like '%abc%';

MySQL 5.7.6 开始后改成了从如下表获取：

performance_schema.global_variables
    performance_schema.session_variables
    performance_schema.variables_by_thread
    performance_schema.global_status
    performance_schema.session_status
    performance_schema.status_by_thread
    performance_schema.status_by_account
    performance_schema.status_by_host
    performance_schema.status_by_user

之前是从如下表获取：

INFORMATION_SCHEMA.GLOBAL_VARIABLES
    INFORMATION_SCHEMA.SESSION_VARIABLES
    INFORMATION_SCHEMA.GLOBAL_STATUS
    INFORMATION_SCHEMA.SESSION_STATUS

比较常用的系统变量和状态变量有：

# 查询慢SQL查询是否开启
    show variables like 'slow_query_log';
    # 查询慢SQL的时间
    show variables like 'long_query_time';
    # 查看慢SQL存放路径，一般：/home/mysql/data3016/mysql/slow_query.log
    show variables like 'slow_query_log_file';
    
    # 查看数据库的事务隔离级别,RDS:READ-COMMITTED   Mysql:Repeatable read
    show variables like 'tx_isolation';
     # innodb数据页大小  16384
    show variables like 'innodb_page_size';
    
    show status  like 'innodb_row_%';
    
    # 查看慢SQL
    SHOW SLOW limit 10;
    show full slow limit 10;
    
    # 查看autocommit配置
    select @@autocommit;
     # 同上
    show variables like 'autocommit';
    #设置SQL自动提交模式  1:默认,自动提交   0:需要手动触发commit,否则不会生效
    set autocommit=1;
    # 查看默认的搜索引擎
    show variables like '%storage_engine%';
    
    # 设置事务隔离级别
    SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;

## 3.5 一些建议 ##

### 3.5.1 小表驱动大表 ###

>  *  nb\_soft\_nature：小表
>  *  nb\_soft：大表
>  *  package\_name：都是索引

MySQL 表关联的算法是 Nest Loop Join(嵌套循环连接)，是通过驱动表的结果集作为循环基础数据，然后一条一条地通过该结果集中的数据作为过滤条件到下一个表中查询数据，然后合并结果。

（1）小表驱动大表

![e8531a5ef57266769fdec203ae671a96.png][]

> nb\_soft\_nature 中只有 24 条数据，每条数据的 package\_name 连接到 nb\_soft 表中做查询，由于 package\_name 在 nb\_soft 表中有索引，因此一共只需要 24 次扫描即可。

### （2）大表驱动小表 ###

![e80030c6e2df7121425f6c1333b4d671.png][]

> 同上，需要 100 多万次扫描才能返回结果

## 3.5.2 使用自增长主键 ##

> 结合 B+Tree 的特点，自增主键是连续的，在插入过程中尽量减少**页分裂**，即使要进行页分裂，也只会分裂很少一部分。并且能减少数据的移动，每次插入都是插入到最后。总之就是减少分裂和移动的频率。

# 四 Redis #

## 4.1 问题处理思路 ##

![9b78f4d761e5c270eea4c8b15c40d037.png][]

## 4.2 内存告警 ##

> 时常会出现下述异常提示信息：

OOM command not allowed when used memory

## 4.2.1 设置合理的内存大小 ##

> 设置 maxmemory 和相对应的回收策略算法，设置最好为物理内存的 3/4，或者比例更小，因为 redis 复制数据等其他服务时，也是需要缓存的。以防缓存数据过大致使 redis 崩溃，造成系统出错不可用。

（1）通过 redis.conf 配置文件指定

maxmemory xxxxxx

（2）通过命令修改

config set  maxmemory xxxxx

### 4.2.2 设置合理的内存淘汰策略 ###

![f00c6f1c68087503c037830c3403b4d4.png][]

（1）通过 redis.conf 配置文件指定

maxmemory-policy allkeys-lru

### 4.2.3 查看大 key ###

（1）有工具的情况下:

> 安装工具 dbatools redisTools,列出最大的前 N 个 key

/data/program/dbatools-master/redisTools/redis-cli-new -h <ip> -p <port> --bigkeys --bigkey-numb 3

得到如下结果:

Sampled 122114 keys in the keyspace!
    Total key length in bytes is 3923725 (avg len 32.13)
    
    
    Biggest string Key Top   1  found 'xx1' has 36316 bytes
    Biggest string Key Top   2  found 'xx2' has 1191 bytes
    Biggest string Key Top   3  found 'xx3' has 234 bytes
    Biggest   list Key Top   1  found 'x4' has 204480 items
    Biggest   list Key Top   2  found 'x5' has 119999 items
    Biggest   list Key Top   3  found 'x6' has 60000 items
    Biggest    set Key Top   1  found 'x7' has 14205 members
    Biggest    set Key Top   2  found 'x8' has 292 members
    Biggest    set Key Top   3  found 'x,7' has 21 members
    Biggest   hash Key Top   1  found 'x' has 302939 fields
    Biggest   hash Key Top   2  found 'xc' has 92029 fields
    Biggest   hash Key Top   3  found 'xd' has 39634 fields

原生命令为：

/usr/local/redis-3.0.5/src/redis-cli -c -h <ip> -p <port> --bigkeys

分析 rdb 文件中的全部 key/某种类型的占用量：

rdb -c memory dump.rdb -t list -f dump-formal-list.csv

查看某个 key 的内存占用量：

[root@iZbp16umm14vm5kssepfdpZ redisTools]# redis-memory-for-key  -s <ip> -p <port> x
    Key             x
    Bytes               4274388.0
    Type                hash
    Encoding            hashtable
    Number of Elements      39634
    Length of Largest Element   29

（2）无工具的情况下可利用以下指令评估 key 大小：

debug object key

## 4.3 Redis 的慢命令 ##

### 4.3.1 设置 Redis 的慢命令的时间阈值(单位：微妙) ###

（1）通过 redis.conf 配置文件方式

# 执行时间大于多少微秒(microsecond，1秒 = 1,000,000 微秒)的查询进行记录。
    slowlog-log-lower-than 1000
    
    # 最多能保存多少条日志
    slowlog-max-len 200

（2）通过命令方式

# 配置查询时间超过1毫秒的， 第一个参数单位是微秒
    config set slowlog-log-lower-than 1000
    
    # 保存200条慢查记录
    config set slowlog-max-len 200

### 4.3.2 查看 Redis 的慢命令 ###

slowlog get

## 4.4 连接过多 ##

（1）通过 redis.conf 配置文件指定最大连接数

maxclients 10000

（2）通过命令修改

config set maxclients xxx

## 4.5 线上 Redis 节点挂掉一个之后的处理流程 ##

## 4.5.1 查看节点状态 ##

> 执行 cluster nodes 后发现会有一个节点 dead：

[rgp@iZ23rjcqbczZ ~]$ /data/program/redis-3.0.3/bin/redis-cli -c -h <ip> -p <port>
    ip:port> cluster nodes
    9f194f671cee4a76ce3b7ff14d3bda190e0695d5 m1 master - 0 1550322872543 65 connected 10923-16383
    a38c6f957f2706f269cf5d9b628586a9372265e9 s1 slave 9f194f671cee4a76ce3b7ff14d3bda190e0695d5 0 1550322872943 65 connected
    77ce43ec23f25f77ec68fe71ae3cb799e7300c6d s2 slave 03d72a3a5050c85e280e0bbeb687056b84f10077 0 1550322873543 63 connected
    03d72a3a5050c85e280e0bbeb687056b84f10077 m2 master - 0 1550322873343 63 connected 5461-10922
    5799070c6a63314296f3661b315b95c6328779f7 :0 slave,fail,noaddr 6147bf416ef216b6a1ef2f100d15de4f439b7352 1550320811474 1550320808793 49 disconnected
    6147bf416ef216b6a1ef2f100d15de4f439b7352 m3 myself,master - 0 0 49 connected 0-5460

### 4.5.2 移除错误节点 ###

（1）一开始执行如下的删除操作失败，需要针对于每一个节点都执行 cluster forget：

ip:port> cluster forget 61c70a61ad91bbac231e33352f5bdb9eb0be6289
    CLUSTER FORGET <node_id> 从集群中移除 node_id 指定的节点

（2）删除挂掉的节点：

[rgp@iZ23rjcqbczZ ~]$ /data/program/redis-3.0.3/bin/redis-trib.rb del-node m3 b643d7baa69922b3fdbd1e25ccbe6ed73587b948
    >>> Removing node b643d7baa69922b3fdbd1e25ccbe6ed73587b948 from cluster m3
    >>> Sending CLUSTER FORGET messages to the cluster...
    >>> SHUTDOWN the node.

（3）清理掉节点配置目录下的 rdb aof nodes.conf 等文件，否则节点的启动会有如下异常：

[ERR] Node s3 is not empty. Either the node already knows other nodes (check with CLUSTER NODES) or contains some key in database 0.

### 4.5.3 恢复节点 ###

（1）后台启动 Redis 某个节点：

/data/program/redis-3.0.3/bin/redis-server /data/program/redis-3.0.3/etc/7001/redis.conf &

（2）将该节点添加进集群：

[root@iZ23rjcqbczZ rgp]# /data/program/redis-3.0.3/bin/redis-trib.rb add-node  --slave --master-id 6147bf416ef216b6a1ef2f100d15de4f439b7352 s3 m3
    >>> Adding node s3 to cluster m3
    >>> Performing Cluster Check (using node m3)
    M: 6147bf416ef216b6a1ef2f100d15de4f439b7352 m3
       slots:0-5460 (5461 slots) master
       0 additional replica(s)
    M: 9f194f671cee4a76ce3b7ff14d3bda190e0695d5 m1
       slots:10923-16383 (5461 slots) master
       1 additional replica(s)
    S: a38c6f957f2706f269cf5d9b628586a9372265e9 s1
       slots: (0 slots) slave
       replicates 9f194f671cee4a76ce3b7ff14d3bda190e0695d5
    S: 77ce43ec23f25f77ec68fe71ae3cb799e7300c6d s2
       slots: (0 slots) slave
       replicates 03d72a3a5050c85e280e0bbeb687056b84f10077
    M: 03d72a3a5050c85e280e0bbeb687056b84f10077 m2
       slots:5461-10922 (5462 slots) master
       1 additional replica(s)
    [OK] All nodes agree about slots configuration.
    >>> Check for open slots...
    >>> Check slots coverage...
    [OK] All 16384 slots covered.
    >>> Send CLUSTER MEET to node s3 to make it join the cluster.
    Waiting for the cluster to join..
    >>> Configure node as replica of m3.
    [OK] New node added correctly.

>  *  s3:本次待添加的从节点 ip：port
>  *  m3:主节点的 ip：port
>  *  6147bf416ef216b6a1ef2f100d15de4f439b7352：主节点编号

# 五 网络 #

## 5.1 排查流程 ##

## 5.1.1 现象出现 ##

> 在非压测或者高峰期的情况下，突然出现大量的 503 等错误码，页面无法打开。

### 5.1.2 查看是否遭受了 DOS 攻击 ###

> 当 Server 上有大量半连接状态且源 IP 地址是随机的，则可以断定遭到 SYN 攻击了，使用如下命令可以让之现行。

netstat -n|grep SYN_RECV

### 5.1.3 查看 TCP 连接状态 ###

> 首先利用以下查看 tcp 总连接数，判断连接数是否正常：

netstat -anoe|grep 8000|wc -l 查看8000

然后利用如下命令判断各个状态的连接数是否正常：

netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'

根据上述信息，如果 TIME\_WAIT 状态数量过多，可利用如下命令查看连接 CLOSE\_WAIT 最多的 IP 地址，再结合业务分析问题：

netstat -n|grep TIME_WAIT|awk '{print $5}'|awk -F: '{print $1}'|sort|uniq -c|sort -nr|head -10

## 5.2 相关知识 ##

### 5.2.1 TCP 连接 ###

TCP 三次握手四次挥手

![2b305931077ce5231886323a15cc9d63.png][] TCP 三次握手四次挥手

为什么在第 3 步中客户端还要再进行一次确认呢？这主要是为了防止已经失效的连接请求报文段突然又传回到服务端而产生错误的场景：

所谓"已失效的连接请求报文段"是这样产生的。正常来说，客户端发出连接请求，但因为连接请求报文丢失而未收到确认。于是客户端再次发出一次连接请求，后来收到了确认，建立了连接。数据传输完毕后，释放了连接，客户端一共发送了两个连接请求报文段，其中第一个丢失，第二个到达了服务端，没有"已失效的连接请求报文段"。

现在假定一种异常情况，即客户端发出的第一个连接请求报文段并没有丢失，只是在某些网络节点长时间滞留了，以至于延误到连接释放以后的某个时间点才到达服务端。本来这个连接请求已经失效了，但是服务端收到此失效的连接请求报文段后，就误认为这是客户端又发出了一次新的连接请求。于是服务端又向客户端发出请求报文段，同意建立连接。假定不采用三次握手，那么只要服务端发出确认，连接就建立了。

由于现在客户端并没有发出连接建立的请求，因此不会理会服务端的确认，也不会向服务端发送数据，但是服务端却以为新的传输连接已经建立了，并一直等待客户端发来数据，这样服务端的许多资源就这样白白浪费了。

采用三次握手的办法可以防止上述现象的发生。比如在上述的场景下，客户端不向服务端的发出确认请求，服务端由于收不到确认，就知道客户端并没有要求建立连接。

SYN 攻击时一种典型的 DDOS 攻击，检测 SYN 攻击的方式非常简单，即当 Server 上有大量半连接状态且源 IP 地址是随机的，则可以断定遭到 SYN 攻击了，使用如下命令可以让之现行：

netstat -nap | grep SYN_RECV

![f3d075389dba84653b2183ef5f69dca2.png][]

### 5.2.2 一些常见问题 ###

（1）为什么 TCP 连接的建立只需要三次握手而 TCP 连接的释放需要四次握手呢?

> 因为服务端在 LISTEN 状态下，收到建立请求的 SYN 报文后，把 ACK 和 SYN 放在一个报文里发送给客户端。而连接关闭时，当收到对方的 FIN 报文时，仅仅表示对方没有需要发送的数据了，但是还能接收数据，己方未必数据已经全部发送给对方了，所以己方可以立即关闭，也可以将应该发送的数据全部发送完毕后再发送 FIN 报文给客户端来表示同意现在关闭连接。
> 
> 从这个角度而言，服务端的 ACK 和 FIN 一般都会分开发送。

（2）如果已经建立了连接，但是客户端突然出现故障了怎么办？

> TCP 还设有一个保活计时器，显然，客户端如果出现故障，服务器不能一直等下去，白白浪费资源。服务器每收到一次客户端的请求后都会重新复位这个计时器，时间通常是设置为 2 小时，若两小时还没有收到客户端的任何数据，服务器就会发送一个探测报文段，以后每隔 75 秒钟发送一次。若一连发送 10 个探测报文仍然没反应，服务器就认为客户端出了故障，接着就关闭连接。

（3）为什么 TIME\_WAIT 状态需要经过 2MSL(最大报文段生存时间)才能返回到 CLOSE 状态？

> 虽然按道理，四个报文都发送完毕，我们可以直接进入 CLOSE 状态了，但是我们必须假象网络是不可靠的，有可以最后一个 ACK 丢失。所以 TIME\_WAIT 状态就是用来重发可能丢失的 ACK 报文。
> 
> 在 Client 发送出最后的 ACK 回复，但该 ACK 可能丢失。Server 如果没有收到 ACK，将不断重复发送 FIN 片段。所以 Client 不能立即关闭，它必须确认 Server 接收到了该 ACK。Client 会在发送出 ACK 之后进入到 TIME\_WAIT 状态。Client 会设置一个计时器，等待 2MSL 的时间。如果在该时间内再次收到 FIN，那么 Client 会重发 ACK 并再次等待 2MSL。所谓的 2MSL 是两倍的 MSL(Maximum Segment Lifetime)。
> 
> MSL 指一个片段在网络中最大的存活时间，2MSL 就是一个发送和一个回复所需的最大时间。如果直到 2MSL，Client 都没有再次收到 FIN，那么 Client 推断 ACK 已经被成功接收，则结束 TCP 连接。

# 六 业务异常日志 #

## 6.1 问题出现 ##

> 主要是通过业务日志监控主动报警或者是查看错误日志被动发现：

![99ce519a96094f33dc59fc1afa285cec.png][]

## 6.2 日志分析 ##

## 6.2.1 确认日志格式 ##

日志格式如下：

### 6.2.2 在日志文件中检索异常 ###

> 利用如下命令可获得异常的详细信息：

cat error.log|grep -n " java.lang.reflect.InvocationTargetException"

![6598877427cf5a474f608427a95850cf.png][]

根据日志格式和日志信息，可获得 traceId 为 489d71fe-67db-4f59-a916-33f25d35cab8，然后利用以下指令获取整个流程的日志信息：

cat biz.log |grep -n '489d71fe-67db-4f59-a916-33f25d35cab8'

![1e417edcafe351c37a43af1fe19f04f1.png][]

### 6.2.3 代码分析 ###

> 然后根据上述流程日志找到对应的代码实现，然后进行具体的业务分析。

[f02e0f5bf6da18764f7c77575a0439b1.png]: /images/20221014/2570bb0830184c49bd567972f442d775.png
[86c44dc142aaa4c4add207f6c9b47d11.png]: /images/20221014/683aad08bfe94e04a3f3ccdcd4989c82.png
[9f189c2f00c101bb5dc8bc2719bde831.png]: /images/20221014/f02d095d37fe4b23be6dae88d475dcfb.png
[e34c720df1fbe58ae31ecf1f7baba299.png]: /images/20221014/61112c26d3184fd0a4303f9748d18217.png
[afbf2f48f66032ca80a1d6209130476a.png]: /images/20221014/c375f85254bd4e54a5fc53a0f43623f6.png
[7db83b725a25d0fa5a9e95dabb6b0c21.png]: /images/20221014/b711dfabf42743feb58bbf50c97dee29.png
[1bb58904c9eb77c47c767d3219b06a63.png]: /images/20221014/0f7ce05a8d3647d1b95b8237720273e1.png
[2e16c5c2f33840dd0fa63c66ce5ca181.png]: /images/20221014/a119dd5ae29549bd9b86338f656e69dd.png
[1d08b77eb79b472823c4900e3d9d10a9.png]: /images/20221014/550fb317f114458498c237acbb4ce9d6.png
[9a8372f89b8ab937ac80a9338f14f974.png]: /images/20221014/47aac86d08f84532b2b6d834edc69e0b.png
[77f12ad5269fcc031d3418aef56cf80b.png]: /images/20221014/560f9842e048493da8d8f8202e56464d.png
[36a9349876c40a6b16513cb0e707d229.png]: /images/20221014/d9204fe70c7743fc9e6b08ac91d8d74e.png
[d8e3357b5545015f7690ab2e8686e8a1.png]: /images/20221014/ccf17f2fc6ca47af935a7235c51ec2da.png
[06f1c33152cdb73764d4a91fc6fb4767.png]: /images/20221014/b2b5da0f60f94c05ba641b8f41627ce0.png
[7710a2eb27f4e682a9ea60830290c198.png]: /images/20221014/2b613a76a3064008bd07e252966ebd58.png
[60f4e818622236923c9d8404d3a38df5.png]: /images/20221014/fcbfb86b477b42ff84b3c3e998df6680.png
[e37fac8c245d8c36a180d68e5b734387.png]: /images/20221014/d21cc07c23b6424887404a1aab44d905.png
[bec1cb2200d238b8f2fb33d1c4d2f510.png]: /images/20221014/6ac467d926fb4290bf65d716d3e931df.png
[b462208175ac4469dbf1026825cf4969.png]: /images/20221014/39f132c8d3d44ac2be860b17838a392c.png
[f75f3281493e4608312c4a32231d08a2.png]: /images/20221014/10999c8ce3ca48b7a1928584a4d32a91.png
[c06908a0558746e729c704dbe44a61c5.png]: /images/20221014/7e380dca69db4bc5ae87fe5deb8feb6d.png
[e2c74ccb5aea07f88cf56266abe0ca72.png]: /images/20221014/6e5c588c737540bd985aadf70bb467b9.png
[e62f95212477ce8f53171de4bb0bd3e2.png]: /images/20221014/779a570c5eae4c7dae55a668321ce35c.png
[4eed9e66f3bc02811e69f5fcb0fdd01f.png]: /images/20221014/cf6e5f35e38e4dff9249835b5a8701d9.png
[206154cdc0fa345ef47713140a3fbc60.png]: /images/20221014/6b690edc56ae419b8b052a766cd5c6a2.png
[1bc0187b86f0689dcc297a1123654d72.png]: /images/20221014/5fa44d56414d48f0a259c40516ff489d.png
[eb23efc7c5a1c3c4e8010f87287e7c72.png]: /images/20221014/cd4f901d78da44acba81ba8d71f1d888.png
[5c4f438d64ed3db8da9ddf08e66cad5e.png]: /images/20221014/5b62b151f6a04f76a8105a143e0052cd.png
[0ee879e017069538a28b82be79ade3a0.png]: /images/20221014/f237b35ccb3744b89a7d0ec0e085aa69.png
[40e4181d2770fca84bf0c2ed4ad1f606.png]: /images/20221014/3bc9651329c04f4a93cfd06984688406.png
[b22737d4755487b521a9e55dfed3ca47.png]: /images/20221014/8ff61a730f0546b9814de3c6f9fd59ea.png
[a0ad2bf50a5a1b1f23c8507298516a86.png]: /images/20221014/b17277d7c77d4691a2ad17371c70b20d.png
[87bc929c9e7c000ad0bf0c1267bd270f.png]: /images/20221014/d8f103c05e4f4e21937306c90b460a7d.png
[427fb81eb6a922519a846ef7473768f0.png]: /images/20221014/17cd8f76f7224522a420b12983e5d105.png
[b1f3bc29f7bde46b48a2096d52463dbd.png]: /images/20221014/aa20c908df73450eb04d69ac0241620f.png
[3fb60fff5ff1be2637da9ffb302570d0.png]: /images/20221014/89dfd1fecc83492cb142fa1174920200.png
[9ebf33a07663cfc3a5b6d0b2287497b5.png]: /images/20221014/64d447f98e19431a9eb924a9252566a5.png
[06a17f1537b9a8d4bff7b20b8f12fcba.png]: /images/20221014/951cd8ed7e5049e89d9518db05d1a7f5.png
[2d1b65131aa949489f5af8c4e34ad2ec.png]: /images/20221014/96859aa370504ed59bcd4b3c7d927e66.png
[657fd2e835504aba8f7d1a42684f33d9.png]: /images/20221014/d38bde4315a5466aac3eb056da6d73e4.png
[e04b1a571cf20870b52ebb59c1809dd5.png]: /images/20221014/88c414c410af4e3e97734109a4f7dae5.png
[989343394d0a97a2d51425ae042db163.png]: /images/20221014/c4d9f1c35e414895aac3a6d1e3df76f6.png
[dec296e005958617a9917f970625bb8e.png]: /images/20221014/32e02685650841e8bf0e6fdf884a132f.png
[411f7c3b15ff4100c1cb62f5b8c52fff.png]: /images/20221014/ebc53c4564ff4ca691568c915cb68666.png
[5fbeb2d3a00d730f3a174281230288e5.png]: /images/20221014/c529491580cc48fb953e5dc7e51f8d93.png
[c7bbcae1307481f6d85e3b47f3a62b4a.png]: /images/20221014/d497695b88ba4c8fb46bfcc014eb5ae6.png
[c001963b3c86ee031b941e3a59d9e4ae.png]: /images/20221014/0f8544b277a748dd9a24031bca0196e7.png
[ced3ac1463c86f49955d9698441d2a84.png]: /images/20221014/70c596c730944bd899ce86ca4c56b124.png
[eb87edb43d6de2745760221a0160b5cb.png]: /images/20221014/5f01373a69194e0faf621ae6c81a4fb7.png
[93c095c9a1a403de2dc70072a478d84a.png]: /images/20221014/41a7ac49c6264c2d9ccedf163bd248da.png
[c23a192978a4b92f685303f575ba5969.png]: /images/20221014/ef1ad4d3a1ea4858b3833c5c1fb1f75a.png
[9c1585718a7c8d06224ce4807a917366.png]: /images/20221014/c7fa95ef9fb64dd19d0633f36aa75428.png
[1d886637fcd9568225c9712cf6a3209c.png]: /images/20221014/7ed81e9e278e451dbb9b83dd8bd75701.png
[4f7c31aee863d5b7fda05ecaac214679.png]: /images/20221014/5d359dcf678647f39159d5b77b57e739.png
[17ed81a7d9051abd186d1609c4bf00a9.png]: /images/20221014/01597f8f6ce64d4c957fcd5e52966689.png
[a69b5534a82ceb015401fc2faa37a6ae.png]: /images/20221014/16ad033701194765ae25cbe713930cf8.png
[3702e8979ef96dd5981d4542f5335dfb.png]: /images/20221014/103d300225de4eff9b6d0fed2696ce93.png
[8e1c4e89f7cbc3cc6aa77ae9328d5b5c.png]: /images/20221014/f867d6c0af4945c1ab208c7ce8a62c3b.png
[61f204fc522d8e3bd4511736c0cbad00.png]: /images/20221014/1d97f8a967c047449a9963ed67415690.png
[6c035b2765c3edf5d504f02352e12652.png]: /images/20221014/dda5e08851f944bc982008e19ccda460.png
[65b274ffd5d70d46e7cf2e3f1afdf5b7.png]: /images/20221014/535fa844533143be80115e1951abfbe9.png
[2d954bc5130dcfcdeebfb1d741fda61a.png]: /images/20221014/c433773c4fa24a85a7173abd0e828d40.png
[e8531a5ef57266769fdec203ae671a96.png]: /images/20221014/3a0d9596222647bcae132b0aff110bf6.png
[e80030c6e2df7121425f6c1333b4d671.png]: /images/20221014/cda31afe879146b19d765ed4a9db6d77.png
[9b78f4d761e5c270eea4c8b15c40d037.png]: /images/20221014/c418652abb694c9594e4abcbf5e435f4.png
[f00c6f1c68087503c037830c3403b4d4.png]: /images/20221014/b7751eabc79d4cf6a848269121b295f9.png
[2b305931077ce5231886323a15cc9d63.png]: /images/20221014/9d9d328582a340b18f376427932f3b93.png
[f3d075389dba84653b2183ef5f69dca2.png]: /images/20221014/0ddf18e894e04031a09d54606f072a20.png
[99ce519a96094f33dc59fc1afa285cec.png]: /images/20221014/253499f40f4c44a3a53c7d32feac3eea.png
[6598877427cf5a474f608427a95850cf.png]: /images/20221014/d7d804f8500745f28d5a6b9f8c5d9316.png
[1e417edcafe351c37a43af1fe19f04f1.png]: /images/20221014/f3b6814fcb844bc7a2d36d8eaccd12a7.png