引言

协程（goroutine）是 Go 语言中实现轻量级线程的一种机制。它由 Go 运行时（GPM调度模型）调度管理，可以在单个操作系统线程上并发执行多个 goroutine。

1. goroutine 概念

• 轻量级：
• goroutine 的创建和调度在操作系统的用户空间执行，所以其成本远低于传统的线程。
• 示例：

go func() { /* ... */ }()

• 调度管理：
• goroutine 由 Go 运行时调度器管理，可以在多个 CPU 核心上并行执行。
• 示例：

runtime.NumCPU() // 返回可用 CPU 核心数量

• 资源高效：
• goroutine 占用较少的系统资源，使得程序可以创建成千上万个 goroutine。
• 示例：

var wg sync.WaitGroup 
for i := 0; i < 10000; i++ { 
 wg.Add(1) 
 go func() { 
 defer wg.Done() 
	 /* ... */ 
 }() 
} 
wg.Wait()

2. goroutine 基本用法

• 启动 goroutine：
• 使用 go 关键字启动一个新的 goroutine。
• 示例：

go printHello()

• 同步等待：
• 使用 sync.WaitGroup 来同步等待所有 goroutine 完成。
• 示例：

var wg sync.WaitGroup 
wg.Add(1) 
go func() { 
 defer wg.Done() 
 fmt.Println("Hello from goroutine!") 
}() 
wg.Wait()

• 通道通信：
• 使用通道在 goroutine 之间传递数据。
• 示例：

ch := make(chan int) 
go func() { 
 ch <- 42 
}() 
result := <-ch 
fmt.Println(result)

• goroutine 退出：
• goroutine 在其函数返回时自动退出。
• 示例：

go func() { 
 fmt.Println("Starting goroutine...") 
 time.Sleep(time.Second) 
 fmt.Println("Exiting goroutine.") 
}()

3.小试牛刀

// https://go.dev/play/p/S8vLOoGuuQG
package main

import (
  "fmt"
  "sync"
  "time"
)

func printHello() {
  fmt.Println("Hello from goroutine!")
}

func main() {
  // 启动 goroutine
  go printHello()

  // 启动多个 goroutine 并等待完成
  var wg sync.WaitGroup
  wg.Add(2)
  go func() {
    defer wg.Done()
    fmt.Println("First goroutine")
  }()
  go func() {
    defer wg.Done()
    fmt.Println("Second goroutine")
  }()
  wg.Wait()

  // 使用通道通信
  ch := make(chan int)
  go func() {
    ch <- 42
  }()
  result := <-ch
  fmt.Println("Result:", result)

  // 使用通道同步
  done := make(chan struct{})
  go func() {
    fmt.Println("Sleeping...")
    time.Sleep(time.Second)
    fmt.Println("Done sleeping.")
    close(done)
  }()
  <-done
}

4. goroutine 和通道的最佳实践

• 避免共享内存：
• 使用通道来替代共享内存，以减少竞态条件的风险。
• 示例：

ch := make(chan int) 
go func() { 
 ch <- 42 
}() 
result := <-ch

• 通道关闭：
• 使用 close 函数关闭不再使用的通道。
• 示例：
• close(ch)
• 错误处理：
• 在 goroutine 中处理错误，并确保错误能够正确传播到主 goroutine。
• 示例：

chErr := make(chan error) 
go func() { 
 err := doSomething() 
 if err != nil { 
		chErr <- err 
 } 
}() 
if err := <-chErr; err != nil { 
 handle(err) 
}

#go##协程##并发#