面试题：Go中defer与goroutine复杂交互及优化

1. 分析defer的开销

思路：defer语句会在函数返回时执行，它会将需要执行的语句压入栈中。频繁使用defer会增加栈操作的开销，特别是在高并发环境下，栈操作可能成为性能瓶颈。
代码修改方向：尽量减少不必要的defer使用。如果一些清理操作可以提前执行，就不要使用defer。例如，文件操作可以在使用完毕后立即关闭，而不是依赖defer。

// 原代码
func readFile() ([]byte, error) {
   file, err := os.Open("test.txt")
   if err != nil {
      return nil, err
   }
   defer file.Close()
   return ioutil.ReadAll(file)
}

// 修改后
func readFile() ([]byte, error) {
   file, err := os.Open("test.txt")
   if err != nil {
      return nil, err
   }
   data, err := ioutil.ReadAll(file)
   file.Close()
   return data, err
}

2. 避免在循环中使用defer

思路：在循环内部使用defer会导致每次迭代都增加一个defer语句到栈中，随着循环次数增多，栈的大小会迅速增长，增加内存消耗和栈操作的性能开销。
代码修改方向：将defer操作移到循环外部。

// 原代码
func processItems(items []int) {
   for _, item := range items {
      file, err := os.Open(fmt.Sprintf("%d.txt", item))
      if err != nil {
         continue
      }
      defer file.Close()
      // 处理文件内容
   }
}

// 修改后
func processItems(items []int) {
   for _, item := range items {
      file, err := os.Open(fmt.Sprintf("%d.txt", item))
      if err != nil {
         continue
      }
      // 处理文件内容
      file.Close()
   }
}

3. 优化defer中的操作

思路：如果defer语句中执行的操作本身比较耗时，如复杂的数据库事务回滚、大量数据的日志记录等，这会影响性能。
代码修改方向：尽量简化defer中的操作。对于复杂操作，可以考虑异步执行。例如，使用goroutine和channel来异步处理日志记录。

// 原代码
func doWork() {
   defer func() {
      // 复杂的日志记录操作
      logFile, err := os.OpenFile("work.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
      if err != nil {
         return
      }
      defer logFile.Close()
      // 写入大量日志数据
      logFile.WriteString("Some complex log data...")
   }()
   // 主要工作逻辑
}

// 修改后
var logChan = make(chan string)
func init() {
   go func() {
      logFile, err := os.OpenFile("work.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
      if err != nil {
         return
      }
      defer logFile.Close()
      for logData := range logChan {
         logFile.WriteString(logData)
      }
   }()
}

func doWork() {
   defer func() {
      logChan <- "Some complex log data..."
   }()
   // 主要工作逻辑
}

4. 考虑使用sync.Pool

思路：如果defer语句中涉及到对象的创建和销毁，如数据库连接对象、缓冲区对象等，可以使用sync.Pool来复用对象，减少内存分配和垃圾回收的开销。
代码修改方向：创建一个sync.Pool实例，并在需要时从池中获取对象，使用完毕后放回池中。

var bufferPool = sync.Pool{
   New: func() interface{} {
      return make([]byte, 1024)
   },
}

func processData() {
   buffer := bufferPool.Get().([]byte)
   defer func() {
      bufferPool.Put(buffer)
   }()
   // 使用buffer处理数据
}

星途面试题库

面试题：Go中defer与goroutine复杂交互及优化

知识考点

面试题答案

1. 分析defer的开销

2. 避免在循环中使用defer

3. 优化defer中的操作

4. 考虑使用sync.Pool