Golang并发如何避免goroutine泄漏

Goroutine泄漏指goroutine无法正常结束，长期占用资源导致程序崩溃。解决方案包括：1.Context控制：使用context.WithCancel或context.WithTimeout创建可取消的上下文，在goroutine中监听context.Done()通道并在接收到信号后退出；2.通道关闭：在不再发送数据时关闭通道，接收方通过for...range自动退出；3.sync.WaitGroup：调用Add(1)和Done()配合Wait()确保所有goroutine完成；4.超时机制：结合time.After与select语句防止阻塞；5.错误处理：使用recover捕获panic以避免程序崩溃。

Golang并发编程中，goroutine泄漏是指启动的goroutine因为某些原因无法正常结束，长期占用资源，最终可能导致程序崩溃。避免goroutine泄漏的关键在于理解goroutine的生命周期，并掌握资源回收技巧，确保每个goroutine在完成任务后能够安全退出。

解决方案：

1. Context控制： 使用context.Context控制goroutine的生命周期。通过context.WithCancel、context.WithTimeout等函数创建带有取消信号的context，当需要结束goroutine时，调用cancel()函数，goroutine监听context.Done()通道，接收到取消信号后执行退出逻辑。

   package main
   
   import (
       "context"
       "fmt"
       "time"
   )
   
   func worker(ctx context.Context, id int) {
       defer fmt.Printf("Worker %d exiting\n", id)
       for {
           select {
           case <-ctx.Done():
               fmt.Printf("Worker %d received cancel signal\n", id)
               return
           default:
               fmt.Printf("Worker %d doing work\n", id)
               time.Sleep(time.Second)
           }
       }
   }
   
   func main() {
       ctx, cancel := context.WithCancel(context.Background())
   
       for i := 1; i <= 3; i++ {
           go worker(ctx, i)
       }
   
       time.Sleep(3 * time.Second)
       cancel() // 发送取消信号
   
       time.Sleep(time.Second) // 等待goroutine退出
       fmt.Println("Program exiting")
   }

2. 通道关闭： 如果goroutine通过通道接收数据，确保在不再需要发送数据时关闭通道。接收方可以通过for...range循环遍历通道，当通道关闭时，循环会自动结束，goroutine即可退出。

   

   package main
   
   import (
       "fmt"
       "time"
   )
   
   func receiver(ch <-chan int, id int) {
       defer fmt.Printf("Receiver %d exiting\n", id)
       for val := range ch {
           fmt.Printf("Receiver %d received: %d\n", id, val)
       }
       fmt.Printf("Receiver %d channel closed\n", id)
   }
   
   func main() {
       ch := make(chan int, 10)
   
       for i := 1; i <= 2; i++ {
           go receiver(ch, i)
       }
   
       for i := 0; i < 5; i++ {
           ch <- i
           time.Sleep(time.Millisecond * 500)
       }
   
       close(ch) // 关闭通道
   
       time.Sleep(time.Second)
       fmt.Println("Program exiting")
   }

3. sync.WaitGroup： 使用sync.WaitGroup等待所有goroutine完成。在启动goroutine之前，调用Add(1)，在goroutine退出时，调用Done()，主goroutine调用Wait()阻塞，直到所有goroutine都调用了Done()。

   package main
   
   import (
       "fmt"
       "sync"
       "time"
   )
   
   func worker(id int, wg *sync.WaitGroup) {
       defer wg.Done() // goroutine退出时调用Done()
       defer fmt.Printf("Worker %d exiting\n", id)
   
       fmt.Printf("Worker %d starting\n", id)
       time.Sleep(time.Second)
       fmt.Printf("Worker %d done\n", id)
   }
   
   func main() {
       var wg sync.WaitGroup
   
       for i := 1; i <= 3; i++ {
           wg.Add(1) // 启动goroutine前调用Add(1)
           go worker(i, &wg)
       }
   
       wg.Wait() // 等待所有goroutine完成
       fmt.Println("All workers done")
   }

4. 超时机制： 为goroutine设置超时时间，防止goroutine因为某些原因一直阻塞。可以使用time.After结合select语句实现超时机制。

   package main
   
   import (
       "fmt"
       "time"
   )
   
   func longRunningTask(ch chan string) {
       time.Sleep(5 * time.Second) // 模拟耗时操作
       ch <- "Task completed"
   }
   
   func main() {
       ch := make(chan string)
       go longRunningTask(ch)
   
       select {
       case result := <-ch:
           fmt.Println(result)
       case <-time.After(2 * time.Second):
           fmt.Println("Task timed out")
       }
   
       fmt.Println("Program exiting")
   }

5. 错误处理： 在goroutine中进行错误处理，避免因为panic导致goroutine无法正常退出。可以使用recover捕获panic，并进行相应的处理。

   package main
   
   import (
       "fmt"
       "time"
   )
   
   func worker(id int) {
       defer func() {
           if r := recover(); r != nil {
               fmt.Printf("Worker %d recovered from panic: %v\n", id, r)
           }
           fmt.Printf("Worker %d exiting\n", id)
       }()
   
       fmt.Printf("Worker %d starting\n", id)
       // 模拟可能panic的情况
       panic("Something went wrong")
       fmt.Printf("Worker %d done\n", id) // 这行代码不会执行
   }
   
   func main() {
       go worker(1)
   
       time.Sleep(time.Second)
       fmt.Println("Program exiting")
   }

如何使用select语句优雅地处理多个通道？

select语句是Golang中处理并发的重要工具，它允许goroutine同时监听多个通道，并在其中一个通道准备好时执行相应的操作。使用select可以避免goroutine阻塞在某个通道上，提高程序的并发性能。

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go func() {
        time.Sleep(2 * time.Second)
        ch1 <- "Message from channel 1"
    }()

    go func() {
        time.Sleep(1 * time.Second)
        ch2 <- "Message from channel 2"
    }()

    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-ch1:
            fmt.Println("Received from channel 1:", msg1)
        case msg2 := <-ch2:
            fmt.Println("Received from channel 2:", msg2)
        }
    }
}

select语句的几个关键点：

• 随机选择： 如果多个通道都准备好，select会随机选择一个执行。
• default分支： 如果所有通道都未准备好，且存在default分支，则执行default分支，避免阻塞。
• 阻塞： 如果所有通道都未准备好，且没有default分支，则select语句会阻塞，直到至少有一个通道准备好。

理解defer的执行顺序和使用场景？

defer语句用于延迟执行函数调用，它会在包含defer语句的函数执行完毕后，按照defer语句的逆序执行。defer常用于资源释放、错误处理等场景。

package main

import "fmt"

func main() {
    defer fmt.Println("Deferred call 1")
    defer fmt.Println("Deferred call 2")
    fmt.Println("Main function")
}

输出结果：

Main function
Deferred call 2
Deferred call 1

defer的常见使用场景：

• 资源释放： 在打开文件、数据库连接等资源后，使用defer关闭资源，确保资源在使用完毕后能够及时释放。

  package main
  
  import (
      "fmt"
      "os"
  )
  
  func main() {
      file, err := os.Open("example.txt")
      if err != nil {
          fmt.Println("Error opening file:", err)
          return
      }
      defer file.Close() // 确保文件关闭
  
      // ... 使用文件
      fmt.Println("File opened successfully")
  }

• 错误处理： 使用recover捕获panic，并进行相应的处理，避免程序崩溃。

  package main
  
  import "fmt"
  
  func main() {
      defer func() {
          if r := recover(); r != nil {
              fmt.Println("Recovered from panic:", r)
          }
      }()
  
      // 模拟可能panic的情况
      panic("Something went wrong")
  }

如何使用go vet和go lint进行代码质量检查？

go vet和go lint是Golang提供的代码静态分析工具，用于检查代码中潜在的问题，提高代码质量。

• go vet： go vet是Golang自带的静态分析工具，它可以检查代码中常见的错误，例如未使用的变量、错误的格式化字符串等。

  go vet ./...

• go lint： go lint是一个第三方静态分析工具，它可以检查代码风格是否符合Golang的规范，例如变量命名、注释等。 首先需要安装golint：

  go install golang.org/x/lint/golint@latest

  然后运行：

  golint ./...

通过定期运行go vet和go lint，可以及时发现并修复代码中的问题，提高代码质量和可维护性。