这是我参与「第三届青训营 -后端场」笔记创作活动的的第1篇笔记

Go 高质量编程与性能调优

什么是高质量？

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

• 各种边界条件是否考虑完备
• 异常情况处理，稳定性保证
• 易读易维护

如何编写高质量 Go 代码

编码规范

代码格式

「gofmt」

Go 语言官方提供的工具，能自动格式化 Go 代码为官方统一风格

常用的 IDE 都支持方便的配置，像「GoLand」自动启用该工具，在每次保存代码都进行格式化

「goimports」

也是 Go 语言官方提供的工具，实际等于「gofmt」加上依赖包管理

自动增删依赖的包，引用、将依赖包按字母序排序并分类

注释

Good code has lots of comments,bad code requires lots of comments

好的代码有很多注释，坏代码需要很多注释。

—— Dave Thomas and Andrew Hunt

注释应该解释代码作用

• 适合注释公共符号

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

• 适合注释实现过程

注释应该解释代码实现的原因

• 适合解释代码的外部因素
• 提供额外上下文

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

• 适合代码的限制条件

公共符号始终要注释

• 包中声明的每个公共的符号：变量、常量、函数以及结构都需要添加注释
• 任何既不明显也不简短的公共功能必须予以注释
• 无论长度或复杂程度如何，对库中的任何函数都必须进行注释
• 一个例外：不需要注释实现接口的方法

命名规范

Good naming is like a good joke.If you have to explain it,t s not funny.

好的命名就像一个好笑话。如果你必须解释它，那就不好笑了。

——Dave Cheney

variable

• 简洁胜于冗长

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

  • 例如使用 ServeHTTP 而不是 ServeHttp
  • 使用 XMLHTTPRequest 或者 xmlHTTPRequest

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

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

// Bad
for index := 0; index < len(s); index++ {
    // do something
}
​
// Good
for i := 0; i < len(s); i++ {
    // do something
}
​
// i 和 index 的作用域范宙围仅限于 for 循环内部时
// index 的额外冗长几乎没有增加对于程序的理解

// Good
func (c *Client) send(req *Request, deadline time.Time)
​
// Bad
func (c *Client) send(req *Request, deadline time.Time)
​
// 将 deadline 替换成 t 虽降低了变量名的信息量
// 但 t 常代指任意时间
// deadline 指截止时间，有特定的含义

function

• 函数名不携带包名的上下文信息，因为包，名和函数名总是成对出现的
• 函数名尽量简短
• 当名为 foo 的包某个函数返回类型 Foo 时，可以在函数名省略类型信息而不导致歧义
• 当名为 foo 的包某个函数返回类型 T 时（T 并不是 Foo），可以在函数名中加入类型信息

// http 包中创建服务的函数如何命名更好？
​
// Good
func Serve(I net.Listener, handler Handler) error
​
// Bad
func ServeHTTP(I net.Listener, handler Handler) error

package

• 只由小写字母组成。不包含大写字母和下划线等字符
• 简短并包含一定的上下文信息。例如 schema、task 等
• 不要与标准库同名。例如不要使用 sync 或者 strings

以下规则为尽量满足：

• 不使用常用变量名作为包名。例如使用 bufio 而不是 buf
• 使用单数而不是复数。例如使用 encoding 而不是 encodings
• 谨慎地使用缩写。例如使用 fmt 在不破坏上下文的情况下比 format 更加简短

控制流程

避免嵌套，保持正常流程清晰

// Bad
if foo {
    return x
} else {
    return nil
}
​
// Good
if foo {
    return x
}
return nil

尽量保持正常代码路径为最小缩进

• 优先处理错误情况/特殊情况，尽早返回或继续循环来减少嵌套

// Bad
func OneFunc() error {
    err := doSomething()
    if err == nil {
        err := doAnotherThing()
        if err == nil {
            return nil  // normal case
        }
        return err
    }
    return err
}
​
// Good
func OneFunc() error {
    if err := doSomething(); err != nil {
        return err
    }
    if err := doAnotherThing(); err != nil {
        return err
    }
    return nil
}

错误和异常处理

简单错误

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

错误的 Wrap 和 Unwrap

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

list, _, err := c.GetBytes(cache.Subkey(a.actionID, "srcfiles"))
if err != nil {
    return fmt.Errorf("reading srcfiles list: %w", err)
}

错误判定

• 判定一个错误是否为特定错误，使用 errors.ls
• 不同于使用 ==，使用该方法可以判定错误链上的所有错误是否含有特定的错误

data, err = lockedfile.Read(targ)
if errors.Is(err, fs.ErrNotExist) {
    return []byte{}, nil
}
return data, err

• 在错误链上获取特定种类的错误，使用 errors.As

if _, err := os.Open("non-existing"); err != nil {
    var pathError *fs.PathError
    if errors.As(err, &pathError) {
        fmt.Println("Failed at path:", pathError.Path)
    } else {
        fmt.Println(err)
    }
}

Panic

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

recover

• recover只能在被defer的函数中使用
• 嵌套无法生效
• 只在当前 goroutine 生效
• defer 的语句是后进先出
• 如果需要更多的上下文信息，可以 recover 后在 log 中记录当前的调用栈

性能优化建议

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

Benchmark

性能表现需要实际数据衡量

Go 语言提供了支持基准性能测试的「benchmark」工具

go test -bench=. -benchmem

// 计算斐波拉契数列函数
// from fib.go
func Fib(n int) int {
    if n < 2 {
        return n
    }
    return Fib(n-1) + Fib(n-2)
}
// from fib_test.go
func BenchmarkFib10(b * testing.B) {
    for n := 0; n < b.N; n++ {
        Fib(10)
    }
}

结果说明：

性能优化建议 - Slice

slice 预分配内存

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

func NoPreAlloc(size int){
    data := make([]int, 0)
    for k := 0; k < size; k++ {
        data = append(data, k)
    }
}
​
func PreAlloc(size int){
    data := make([]int, 0, size)
    for k := 0; k < size; k++ {
        data = append(data, k)        
    }
)

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

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

• 场景

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

• 可使用 copy 替代 re-slice

func GetLastByslice(origin []int) []int {
    return origin[len(origin)-2:]
}
​
func GetLastByCopy(origin []int) []int {
    result := make([]int, 2)
    copy(result, origin[len(origin)-2:])
    return result
}

性能优化建议 - Map

预分配内存

func NoPreAlloc(size int){
    data make(map[int]int)
    for i := 0; i < size; i++ {
        data[i] = 1    
    }
}
​
func NoPreAlloc(size int){
    data make(map[int]int, size)
    for i := 0; i < size; i++ {
        data[i] = 1    
    }
}

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

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

使用 strings.Builder 进行字符串拼接

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

分析：

• 字符串在 Go 语言中是不可变类型，占用内存大小是固定的
• 使用 + 每次都会重新分配内存
• strings.Builder，bytes.Buffer 底层都是 []byte 数组
• 内存扩容策略，不需要每次拼接重新分配内存

性能优化建议 - 空结构体

使用空结构体节省内存

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

• 可作为各种场景下的占位符使用

  • 节省资源
  • 空结构体本身具备很强的语义，即这里不需要任何值，仅作为占位符

// 实现 Set
func EmptystructMap(n int){
    m := make(map[int]struct{})
    
    for i := 0;i < n; i++ {
        m[i] = struct{}{}
    }
}
​
func BoolMap(n int) {
    m := make(map[int]bool)
    
    for i := 0;i < n; i++ {
        m[i] = false
    }
}

• 实现 Set,可以考虑用 map 来代替
• 对于这个场景，只需要用到 map 的键，而不需要值
• 即使是将 map 的值设置为 bool 类型，也会多占据 1 个字节空间

性能优化建议 - atomic 包

// 加锁
type mutexCounter struct {
    i int32
    m sync.Mutex
}
​
func MutexAddOne(c *mutexCounter) {
    c.m.Lock()
    c.i++
    c.m.Unlock()
}
​
// 利用 atomic 包
type atomicCounter struct {
    i int32
}
​
func AtomicAddone(c *atomicCounter){
    atomic.AddInt32(&c.i, 1)
}

• 锁的实现是通过操作系统来实现，属于系统调用
• atomic 操作是通过硬件实现，效率比锁高
• sync.Mutex 应该用来保护一段逻辑，不仅仅用于保护一个变量
• 对于非数值操作，可以使用 atomic.Value，能承载一个 interfacef{}

性能调优实战

性能调优原则

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

既然性能调优前提是对应用程序性能表现有实际的数据指标，那么有什么工具能够获得这种数据呢？

对于 Go 程序，有一个很方便的工具就是 pprof，pprof 是用于可视化和分析性能分析数据的工具

对于 pprof 工具实战可参考博客： golang pprof 实战 | Wolfogre's Blog

参考

「高质量编程与性能调优实战」第三届字节跳动青训营 - 后端专场 - 直播课