Go高质量编程与性能调优 | 青训营笔记

用户6372872986752
63 阅读5分钟

这是我参与「第五届青训营 」笔记创作活动的第3天

本堂课重点

  • 编码的原则
  • 编码规范
  • 性能优化建议
  • 性能调优工具

高质量编程

高质量的含义

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

编码的原则

  • 简单性：以简单的逻辑就能解决问题，能够让其他人一看就懂
  • 可读性： 确保自己写的代码自己能够读懂
  • 生产力： 团队合作至关重要

编码规范

代码格式

有两种工具可以帮助我们解决

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

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

注释

注释应该做到：

  • 注释应该解释代码作用
  • 注释应该解释代码如何做的
  • 注释应该解释代码实现的原因
  • 注释应该解释代码什么情况会出错 注意：公共符号要始终要注释的，有一个例外，不需要注释实现接口的方法。

命名规范

变量

  • 简洁胜于冗长
  • 缩略词全大写，但当其位于变量开头且不需要导出时，使用全小写
    • 例如使用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的额外冗长几乎没有增加对于程序的理解

函数

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

包名

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

控制流程

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

// Bad
if foo {
        return x
    }else {
        return nil
    }
//Good
if foo {
    return x
}
    return nil
如果分支语句都含义return，则可以去除冗余的return

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

// 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 i
        return err
    }
    if err := doAnotherThing(); err != nil {
        return err
    }
    return nil // normal case
}
优先处理错误情况/特殊情况，尽早返回或继续循环来减少嵌套，将代码进行合并

错误和异常处理

简单错误

  • 简单的错误指的是仅出现一次的错误，且在其他地方不需要捕获该错误
  • 优先使用errors.New来创建匿名变量来直接表示简单错误
  • 如果有格式化的需求，使用fmt.Errorf
func defaultCheckRedirect(req *Request，via []*Request) error {
    if len(via) >=10 {
        return errors. New( "stopped after 10 redirects" )
    }
    return nil
}

错误的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.Is
  • 不同于使用==，使用该方法可以判定错误链上的所有错误是否含有特定的错误
data,err = lockedfile.Read(targ)
if errors.Is(err,fs.ErrNotExist) {
    // Treat non-existent as empty，to bootstrap the "latest" file
    // the first time we connect to a given database.访密
    return [ ]byte{},nil
}
return data,err
  • 在错误链上获取特定种类的错误,使用errors.As
if _, err := os.0pen( "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
func main( ) {
    //...
    ctx,cancel := context.withCancel(context. Background())
    client，err := sarama. NewConsumerGroup( strings. Split( brokers," , " )，group，config )
    if err != nil {
        log.Panicf( "Error creating consumer group client: %v",err)
    }
    // ...
}
// Panicf is equivalent to Printf( ) followed by a call to panic( ).func Panicf( format string, v ...interface{}) {
    S :=fmt.Sprintf( format， v...)
    std. 0utput(2，s)
    panic(s )
}

recover

  • recover只能在被defer的函数中使用
  • 嵌套无法生效
  • 只在当前goroutine 生效
  • defer的语句是后进先出
func ( s *ss ) Token( skipSpace bool， f func( rune) bool)( tok [ ]byte,err error) {
    defer func( ) {
        if e := recover( ); e!= nil {
            if se, ok := e.(scanError); ok {
                err = se.err
            }else {
                panic(e )
            }
        }
    }()
    //...
}

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

性能优化建议

Benchmark

使用方法：go test -bench=. -benchmem 结果介绍： image.png

Slice

使用slice分配内存时，尽量预先分配内存，这样有助于提升性能

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)
    }
}

image.png 因为切片的本质是一个数组的片段，切片的操作是针对原数组，因此如果原数组很大的，操作切出一个很小的数组，如果操作这个切片，会造成性能减缓，因此我们可以用copy(新数组，切片)替代re-slice

Map

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

字符串处理

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

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

空结构体

使用空结构体节省内存

  • 空结构体struct母实例不占据任何的内存空间
  • 可作为各种场景下的占位符使用
    • 节省资源
    • 空结构体本身具备很强的语义，即这里不需要任何值，仅作为占位符
func EmptyStructMap( n int) {
    m:=make( map[int ]structi})
    for i :=0; i < n; i++ {
        m[ i] = struct{}H{}
    }
}
func BoolMap( n int) {
    m:=make(map[int ] bool)
    for i := 0; i < n; i++ {
        m[i] = false
    }
}

atomic包

  • 锁的实现是通过操作系统来实现，属于系统调用
  • atomic操作是通过硬件实现,效率比锁高
  • sync.Mutex应该用来保护一段逻辑，不仅仅用于保护一个变量
  • 对于非数值操作，可以使用atomic.Value，能承载一个interface}
type atomicCounter struct {
    i int32
}
func AtomicAddOne( c*atomicCounter) {
    atomic. AddInt32(&c.i，1)
}

性能分析工具 pprof

image.png

image.png

个人总结

经过这一天的学习，我认识到自己以前写代码的错误，有很多不规范的地方，通过这节课程我将会加以改正，同时今天也学习到很感兴趣的性能调优，认识到我们的代码有时换一种方法可以极大得提高我们得效率。

avatar
文章
阅读
粉丝