一. 高质量编程

1. 高质量编程简介

编写的代码能够达到正确可靠、简洁清晰的目标可称之为高质量代码

各种边界条件是否考虑完备

异常情况处理，稳定性保证

易读易维护

编写原则

简单性：消除"多余的复杂性"，以简单清晰的逻辑编写代码不理解的代码无法修复改进

可读性：代码是写给人看的，而不是机器编写可维护代码的第一步是确保代码可读

生产力：团队整体工作效率非常重要

2. 编码规范

1）. 代码格式

gofmt Go 语言官方提供的工具，能自动格式化 Go 语言代码为官方统一风格堂见DE都支持方便的配置

goimports 也是 Go 语言官方提供的工具实际等于 gofmt 加上依赖包管理自动增删依赖的包引用、将依赖包按字母序排序并分类

2）. 注释

注释应该解释代码作用

注释应该解释代码如何做的

注释应该解释代码实现的原因(适合解释代码的外部因素提供额外上下文)

注释应该解释代码什么情况会出错

公共符号始终要注释

包中声明的每个公共的符号变量、常量、函数以及结构都需要添加注释,

任何既不明显也不简短的公共功能必须予以注释,

无论长度或复杂程度如何对库中的任何函数都必须进行注释.
有一个例外，不需要注释实现接口的方法.

小结

代码是最好的注释注释应该提供代码未表达出的上下文信息

3）. 命名规范

变量命名规范

简洁胜于冗长

缩略词全大写，但当其位于变量开头且不需要导出时，使用全小写

例如使用 ServeHTTP 而不是 ServeHttp，使用 XMLHTTPRequest 或者 xmIHTTPRequest

变量距离其被使用的地方越远，则需要携带越多的上下文信息

全局变量在其名字中需要更多的上下文信息，使得在不同地方可以轻易辨认出其含义

函数命名规范

函数名不携带包名的上下文信息，因为包名和函数名总是成对出现的

函数名尽量简短

当名为 foo 的包某个函数返回类型 Foo 时，可以省略类型信息而不导致歧义

当名为 foo 的包某个函数返回类型 T 时(T 并不是 Foo) ，可以在函数名中加入类型信息

包名命名规范

只由小写字母组成。不包含大写字母和下划线等字符

简短并包含一定的上下文信息。例如 schema、task 等

不要与标准库同名。例如不要使用 sync 或者 strings

以下规则尽量满足，以标准库包名为例

不使用常用变量名作为包名。例如使用 bufio 而不是 buf

使用单数而不是复数。例如使用 encoding 而不是 encodings

谨慎地使用缩写。例如使用 fmt 在不破坏上下文的情况下比 format 更加简短

小结

核心目标是降低阅读理解代码的成本重点考虑上下文信息，设计简洁清晰的名称

4）. 控制流程

避免嵌套，保持正常流程清晰,如果两个分支中都包含return语句，则可以去除冗余的else

尽量保持正常代码路径为最小缩进，优先处理错误情况/特殊情况，尽早返回或继续循环来减少嵌套

小结

线性原理，处理逻辑尽量走直线，避免复杂的嵌套分支
正常流程代码沿着屏幕向下移动
提升代码可维护性和可读性
故障问题大多出现在复杂的条件语句和循环语句中

5）. 错误和异常处理

简单错误

简单的错误指的是仅出现一次的错误，且在其他地方不需要捕获该错误，优先使用 errors.New 来创建匿名变量来直接表示简单错误，如果有格式化的需求，使用 fmt.Errorf。

错误的 Wrap 和 Unwrap

错误的 Wrap 实际上是提供了一个 error 嵌套另一个 error 的能力，从而生成一个 error 的跟踪链，在 fmt.Errorf 中使用: %w 关键字来将一个错误关联至错误链中。

错误判定

判定一个错误是否为特定错误，使用 errors.Is，不同于使用 ==，使用该方法可以判定错误链上的所有错误是否含有特定的错误。在错误链上获取特定种类的错误，使用errors.As

Panic

不建议在业务代码中使用 panic, 调用函数不包含 recover 会造成程序崩溃, 若问题可以被屏蔽或解决，建议使用error 代替 panic, 当程序启动阶段发生不可逆转的错误时可以在 init 或 main 函数中使用 panic,

recover

recover 只能在被 defer 的函数中使用, 嵌套无法生效, 只在当前 goroutine 生效, defer 的语句是后进先出,

如果需要更多的上下文信息，可以 recover 后在 log 中记录当前的调用栈

小结

error 尽可能提供简明的上下文信息链，方便定位问题;

panic 用于真正异常的情况;

recover 生效范围，在当前 goroutine 的被 defer 的函数中生效;

3. 性能优化建议

简介

性能优化的前提是满足正确可靠、简洁清晰等质量因素，性能优化是综合评估，有时候时间效率和空间效率可能对立，针对 Go 语言特性，介绍 Go 相关的性能优化建议。

1）. Benchmark

如何使用

go 复制代码

package jzcs  
  
import "testing"  
  
func BenchmarkSelect(b *testing.B) {  
    InutServerIndex()  //准备时间除去
    b.ResetTimer()  
    for i := 0; i < b.N; i++ {  
        Select()  
    }  
    }  //串行压力测试
func BenchmarkSelectParallal(b *testing.B) {  
    InutServerIndex()  
    b.ResetTimer()  
    b.RunParallel(func(pb *testing.PB) {  
        for pb.Next() {  
            Select()  
        }  
    })  //并行压力测试
}

性能表现需要实际数据衡量， Go 语言提供了支持基准性能测试的 benchmark 工具

BenchmarkCtt-16 是函数名 - 核心数执行次数每次执行花费时间

2）. 性能优化建议-Slice

slice 预分配内存

尽可能在使用 make() 初始化切片时提供容量信息

go 复制代码

data:=make([]int ,0)//没有预留
data:=make([]int ,0,6)//预留了一个6大小的空间

slice 预分配内存

切片本质是一个数组片段的描述，包括数组指针，片段的长度，片段的容量(不改变内存分配情况下的最大长度)

切片操作并不复制切片指向的元素

创建一个新的切片会复用原来切片的底层数组

另一个陷阱: 大内存未释放

在已有切片基础上创建切片，不会创建新的底层数组

原切片较大，代码在原切片基础上新建小切片，原底层数组在内存中有引用，得不到释放

可使用 copy 替代 re-slice

3）. 性能优化建议-Map

map 预分配内存

go 复制代码

data:=make(map[int]int)//没有预留
data:=make(map[int]int,6)//预留了一个6大小的空间

不断向 map 中添加元素的操作会触发 map 的扩容, 提前分配好空间可以减少内存拷贝和 Rehash 的消耗, 建议根据实际需求提前预估好需要的空间

4）. 性能优化建议-字符串处理

使用 strings.Builder

strings.Builder拼接字符串比bytes.Buffer,用和+性能更好

go 复制代码

but :=new(bytes.buffer)
buf:WriteStrung(str)

var butlder strings.Builder
builder.WriteString(str)

使用 + 拼接性能最差，strings.Builder，bytes.Buffer 相近，strings.Buffer 更快

分析：

字符串在 Go 语言中是不可变类型，占用内存大小是固定的

使用 + 每次都会重新分配内存

strings.Builder，bytes.Buffer 底层都是 byte 数组

内存扩容策略，不需要每次拼接重新分配内存

bytes.Buffer 转化为字符串时重新申请了一块空间, strings.Builder 直接将底层的[]byte 转换成了字符串类型返回

5）. 性能优化建议-空结构体

使用空结构体节省内存

空结构体 struct{} 实例不占据任何的内存空间

可作为各种场景下的占位符使用，节省资源，空结构体本身具备很强的语义，即这里不需要，任何值，仅作为占位符

实现 Set，可以考虑用 map 来代替

对于这个场景，只需要用到 map 的键，而不需要值

即使是将 map 的值设置为 bool 类型，也会多占据 1 个字节空间

6）.性能优化建议-atomic 包

锁的实现是通过操作系统来实现，属于系统调用

atomic 操作是通过硬件实现，效率比锁高

sync.Mutex 应该用来保护一段逻辑，不仅仅用于保护-个变量

对于非数值操作，可以使用 atomic.Value，能承载一个 interfaced

go 复制代码

type atomicCounter struct {
    i int32
}

func AtomicAddOne(c *atomicCounter){
    atomic.AddInt32(&c.i,1)
}

小结:

避免常见的性能陷阱可以保证大部分程序的性能

普通应用代码，不要一味地追求程序的性能

越高级的性能优化手段越容易出现问题

在满足正确可靠、简洁清晰的质量要求的前提下提高程序性能

二. 性能调优实战

1. 简介

性能调优原则

要依靠数据不是猜测，要定位最大瓶颈而不是细枝末节，不要过早优化，不要过度优化。

2. 性能分析工具 pprof

说明

希望知道应用在什么地方耗费了多少 CPU、Memory， pprof 是用于可视化和分析性能分析数据的工具

1）pprof 功能简介

2） pprof 排查实战

搭建pprof项目

pprof项目已提前迈入了炸弹代码

前置准备

下载项目代码，能够编译运行，会占用1CPU核心和超过1GB的内存

浏览器看查指标

http://localhost:6060/debug/pprof/

进入网址后能看到许多选项

CPU

CPU等可以用任务管理器看

pprof的采样结果是将一段时间采集到的信息汇总输出到文件中。

可以用下列代码采集 10s后的数据

cmd 复制代码

go tool pprof "http://localhost:6060/debug/pprof/profile?seconds=10"

命令: top

查看占用资源最多的函数

Flat == Cum，函数中没有调用其他函数， Flat == 0，函数中只有其他函数的调用

命令: list

根据指定的正则表达式查找代码行

命令: web 调用关系可视化

Heap-堆内存

cmd 复制代码

go tool pprof -http=:8080 "http://localhost:6060/debug/pprof/heap"

上述代码可以打开可视化网页

这个网页包含上面的top等

alloc_objects: 程序累计申请的对象数

inuse obiects: 程序当前持有的对象数

alloc_space: 程序累计申请的内存大小

inuse_space: 程序当前占用的内存大小

goroutine-协程

goroutine泄露也会导致内存泄露

cmd 复制代码

go tool pprof -http=:8080 "http://localhost:6060/debug/pprof/goroutine"

点击flame Graph 由上到下表示调用顺序

每一块代表一个函数，越长代表占用 CPU 的时间更长

火焰图是动态的，支持点击块进行分析

支持搜索，在 Source 视图下搜索 wolf

mutex-锁

go 复制代码

go tool pprof -http=:8080 "http://localhost:6060/debug/pprof/mutex"

然后下Source下搜索有问题的代码

block-阻塞

和前边一样

但是只处理一个后会发现还有一个阻塞这是因为下面有一些过滤的条件

cmd 复制代码

go tool pprof "http://localhost:6060/debug/pprof/block"

可以从主页上进入看到所有阻塞

3） pprof 的采样过程和原理

CPU

采样对象:函数调用和它们占用的时间

采样率: 100次/秒，固定值

采样时间: 从手动启动到手动结束

开始采样 -> 设定信号处理函数 -> 开启定时器

停止采样 -> 取消信号处理函数 -> 关闭定时器

操作系统 每10ms向进程发送一次SIGPROF信号

进程 每次接收到SIGPROF会记录调用堆栈

写缓冲 每100ms读取已经记录的调用栈并写入输出流

Heap - 堆内存

采样程序通过内存分配器在堆上分配和释放的内存，记录分配/释放的大小和数量

采样率:每分配512KB记录一次，可在运行开头修改，1为每次分配均记录

采样时间:从程序运行开始到采样时

采样指标: alloc_space, alloc_objects, inuse_space, inuse_objects

计算方式: inuse = alloc - free

Goroutine-协程 & ThreadCreate-线程创建

Goroutine 记录所有用户发起且在运行中的 goroutine (即入口非runtime开头的), runtime.main 的调用栈信息

ThreadCreate 记录程序创建的所有系统线程的信息

Goroutine: Stop The World-> 遍历allg切片-> 输出创建g的堆栈-> Start The World

ThreadCreate: Stop The World->-> 遍历allm链表-> 输出创建m的堆栈-> Start The World

Block-阻塞 & Mutex-锁

阻塞操作

采样阻塞操作的次数和耗时

采样率:阻塞耗时超过闯值的才会被记录, 1为每次阻塞均记录

graph LR 阻塞操作 --上报调用栈和消耗时间--> Proiler --采样-->遍历阻塞记录-->统计阻塞次数和耗时 Proiler -->时间未到闯值则丢弃

锁竞争

采样争抢锁的次数和耗时

采样率:只记录固定比例的锁操作，1为每次加锁均记录

graph LR 锁竞争 --上报调用栈和消耗时间--> Proiler --采样-->遍历锁记录-->统计锁竞争次数和耗时 Proiler -->比例未命中则丢弃

3. 性能调优案例

简介介绍实际业务服务性能优化的案例，对逻辑相对复杂的程序如何进行性能调优

1）业务服务优化

基本概念

服务:能单独部署，承载一定功能的程序

依赖: Service A 的功能实现依赖 Service B 的响应结果，称为 Service A 依赖 Service B

调用链路: 能支持一个接口请求的相关服务集合及其相互之间的依赖关系

基础库: 公共的工具包、中间件

流程

建立服务性能评估手段

分析性能数据，定位性能瓶颈

重点优化项改造

优化效果验证

建立服务性能评估手段

服务性能评估方式： 单独 benchmark 无法满足复杂逻辑分析，不同负载情况下性能表现差异

请求流量构造： 不同请求参数覆盖逻辑不同，线上真实流量情况

压测范围： 单机器压测，集群压测

性能数据采集： 单机性能数据，集群性能数据

单机压力测试图

火焰图

压测平台产生的压测报告

分析性能数据，定位性能瓶颈

使用库不规范

找到相应代码进行修改

高并发场景优化不足
高峰期性能数据低峰期性能数据

对比高峰期性能数据和低峰期性能数据对代码进行优化

重点优化项改造

正确性是基础，响应数据 diff: 线上请求数据录制回放，新旧逻辑接口数据 diff

优化效果验证

重复压测验证, 上线评估优化效果: 关注服务监控, 逐步放量, 收集性能数据

进一步优化，服务整体链路分析: 规范上游服务调用接口，明确场景需求, 分析链路，通过业务流程优化提升服务性能

2）基础库优化

AB实验SDK的优化

分析基础库核心逻辑和性能瓶颈: 设计完善改造方案, 数据按需获取, 数据序列化协议优化,

内部压测验证

推广业务服务落地验证

通过火焰图看ab所作战的百分比，然后进行优化

3）Go 语言优化

编译器&运行时优化

优化内存分配策略，优化代码编译流程，生成更高效的程序，内部压测验证，推广业务服务落地验证

优点接入简单，只需要调整编译配置，通用性强

总结 性能调优原则：要依靠数据不是猜测

性能分析工具 pprof：熟练使用 pprof 工具排查性能问题并了解其基本原理

性能调优： 保证正确性，定位主要瓶颈

高质量编程简介及编码规范 | 青训营

一. 高质量编程

1. 高质量编程简介

2. 编码规范

1）. 代码格式

2）. 注释

3）. 命名规范

变量命名规范

函数命名规范

包名命名规范

4）. 控制流程

5）. 错误和异常处理

3. 性能优化建议

1）. Benchmark

2）. 性能优化建议-Slice

3）. 性能优化建议-Map

4）. 性能优化建议-字符串处理

5）. 性能优化建议-空结构体

6）.性能优化建议-atomic 包

二. 性能调优实战

1. 简介

2. 性能分析工具 pprof

1）pprof 功能简介

2） pprof 排查实战

搭建pprof项目

浏览器看查指标

CPU

Heap-堆内存

goroutine-协程

mutex-锁

block-阻塞

3） pprof 的采样过程和原理

CPU

Heap - 堆内存

Goroutine-协程 & ThreadCreate-线程创建

Block-阻塞 & Mutex-锁

3. 性能调优案例

1）业务服务优化

建立服务性能评估手段

分析性能数据，定位性能瓶颈

优化效果验证

2）基础库优化

AB实验SDK的优化

3）Go 语言优化

编译器&运行时优化