go tool trace 跟踪执行过程，程序优化过程

Go并发优化的9大技巧，效果立竿见影

原创 Go先锋 Go先锋 2023-11-10 08:02 发表于广东听全文

Go 先锋

读完需要

8分钟

速读仅需 3 分钟

概述

Go 语言以其在并发编程方面的优势而闻名,但合理利用各种优化技巧可以进一步提升 Go 程序的并发性能。

本文将介绍在 CPU 密集型和 IO 密集型场景下优化 Go 并发程序的常见方法。

主要内容包括

充分利用多核 CPU

减少调度和上下文切换

控制内存占用

选择合适的数据结构

分析性能瓶颈

一、优化 CPU 密集场景

对于计算密集型任务, 可通过以下方法利用多核 CPU

1. 设置 GOMAXPROCS

func init() {  runtime.GOMAXPROCS(runtime.NumCPU()) }

2. 分解问题,并行计算

// 并发求和func sum(s []int) int {  var wg sync.WaitGroup  ch := make(chan int)  for i := range s {    wg.Add(1)    go func(slice []int) {      ch <- sum(slice)      wg.Done()     }(s[i:])  }
  go func() {     wg.Wait()     close(ch)  }()
  var total int   for c := range ch {    total += c  }  return total}

3. 避免不必要的 Goroutine 上下文切换

合理控制 Goroutine 数量,避免过多的 Goroutine 导致调度器负载过重。

二、优化 IO 密集场景

对于 IO 密集型任务, 可通过以下方法并发提高吞吐量

1. 多路复用 IO 操作

func readFromFiles(filenames []string) {   var wg sync.WaitGroup   fileCh := make(chan File)   for _, f := range filenames {      wg.Add(1)      go func(f string) {         fileCh <- readFile(f)          wg.Done()      }(f)   }
   go func() {      wg.Wait()      close(fileCh)   }()
   for r := range fileCh {      process(r)   }}

2.异步处理 IO 请求

使用 bufio.Scanner 等可以异步读取数据。

3.控制并发数

避免过多的 Goroutine 阻塞导致资源耗尽。

三、减少内存使用详解

优化内存使用非常重要,主要可从以下几个方面入手

1. 使用 sync.Pool 对象重用

// 重用解析对象  var parserPool = sync.Pool{  New: func() interface{} {    return &Parser{}   },}
func parse(data []byte) {  p := parserPool.Get().(*Parser)  // 使用p解析  parserPool.Put(p) // 重用}

2. 优化 Goroutine 栈大小

降低栈空间,可以支持更多 Goroutine

g := runtime.NewGoroutineWithStackSize(512 * 1024)

3. 复用缓冲区

重用字节缓冲区,减少内存分配

var buffPool = sync.Pool{  New: func() interface{} {    return make([]byte, 1024)  },} 
func read() {  b := buffPool.Get().([]byte)  // 复用buff  buffPool.Put(b)}

四、选择并发数据结构

读写频繁时优先使用 RWMutex

需要线程安全可以选择 sync.Map

不需要锁的场景可使用原子操作

channel 并发安全但需要合理 buffer 数

无锁数据结构如环形队列

例如

// 环形队列 type ringBuffer struct {  buf []interface{}  count uint64   head, tail uint32}
func (rb *ringBuffer) Push(val interface{}) {  if rb.Full() {     rb.head++ // 头部推进   }    rb.buf[rb.tail] = val  rb.tail++ // 尾部推进  }

五、分析并发程序效率

可用以下工具来分析 Go 并发程序的效率

1. GODEBUG=schedtrace 追踪调度过程

import "runtime"
// 启用调度跟踪runtime.GODEBUG = "schedtrace=1000" 
func main() {  // 执行程序  // 分析log结果}

2. runtime/pprof 做性能分析

import "runtime/pprof"
func main() {  pprof.StartCPUProfile(w io.Writer)  defer pprof.StopCPUProfile()
  // 程序代码
  pprof.WriteHeapProfile(w io.Writer)}

3. go tool trace 跟踪执行过程

go test -trace=trace.out 
go tool trace trace.out# 分析

用这些工具可以直观地分析并发程序的效率问题。

六、爬虫程序优化案例

对一个爬虫程序进行并发优化

var urlPool = make(chan []string)
func main() {  // 使用无锁队列  urlPool = make(chan []string, 10000)
  var wg sync.WaitGroup  // 限制最大并发数  maxG := 100  wg.Add(maxG)  for i := 0; i < maxG; i++ {    go func() {      crawl()      wg.Done()    }()  }  // 分发URL  go distributeUrls()   wg.Wait()  }
func crawl() {  for url := range urlPool {    // 并发获取URL  }}
func distributeUrls() {  // 分批将URL放入channel}

这样通过控制并发数量,重用对象池,使用无锁队列等方法可以优化爬虫程序的并发效率。

总结

Go 语言并发程序的执行效率对程序性能有重大影响。可从以下几个方面进行优化

合理利用多核 CPU,并行执行运算密集型任务,设置 GOMAXPROCS;对 IO 密集型任务,采用异步并发调用提升吞吐量。

控制 Goroutine 数量,避免过多线程导致调度器过载;同时也要避免使用过少线程而不能充分利用 CPU。

优化内存占用,重用对象减少 GC 开销;适当降低 Goroutine 栈空间也有助于支持更多 Goroutine。

选择正确的并发安全数据结构,如无锁数据结构、原子操作等可以提升并发效率。

使用调试和性能分析工具定位效率薄弱点;比如 CPU 分析、阻塞分析等。

充分考虑并发模型的优化,比如管道化消息传递;以及设计异步并发流程等。

针对不同场景设计最优的并发模式,避免共享内存同步等开销。

合理设置并发数,最大程度利用硬件资源而不导致过度调度。

采用最优的数据结构,利用无锁并发安全实现。