Go语言通过goroutine和channel实现高效并发，使用go关键字启动goroutine；2. 主goroutine不等待其他goroutine，需用sync.WaitGroup同步，通过Add、Done、Wait方法确保所有任务完成。
Go语言的并发模型基于goroutine和channel，使得编写高并发程序变得简单高效。goroutine是Go运行时调度的轻量级线程，启动成本低，一个Go程序可以轻松启动成千上万个goroutine。
如何启动一个goroutine
在函数或方法调用前加上go关键字，即可让该函数在新的goroutine中执行。
示例：go func() {<br>
fmt.Println("Hello from goroutine")<br>
}()
主goroutine（main函数）不会等待其他goroutine结束。如果主程序退出，所有未完成的goroutine都会被强制终止。
使用WaitGroup同步多个goroutine
当需要等待一组goroutine完成时，可使用sync.WaitGroup进行同步。
立即学习“go语言免费学习笔记（深入）”；
常用方法：- Add(n)：增加计数器
- Done()：计数器减1
- Wait()：阻塞直到计数器为0
示例代码：
var wg sync.WaitGroup<br><br>
for i := 0; i < 3; i++ {<br>
wg.Add(1)<br>
go func(id int) {<br>
defer wg.Done()<br>
fmt.Printf("Goroutine %d done\n", id)<br>
}(i)<br>
}<br><br>
wg.Wait() // 等待所有goroutine完成
通过channel进行goroutine间通信
channel是goroutine之间传递数据的安全方式，避免了共享内存带来的竞态问题。
创建channel：ch := make(chan string)
向channel发送数据：ch <br>从channel接收数据：<code>value :=
Golang Uber Dig
下载
使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等
带缓冲的channel：
ch := make(chan int, 5) // 缓冲大小为5
缓冲channel非阻塞发送，直到缓冲区满为止。
实际应用示例：生产者-消费者模型
func producer(ch chan<- int) {<br>
for i := 0; i < 5; i++ {<br>
ch <- i<br>
time.Sleep(time.Millisecond * 100)<br>
}<br>
close(ch)<br>
}<br><br>
func consumer(ch <-chan int, wg *sync.WaitGroup) {<br>
defer wg.Done()<br>
for value := range ch {<br>
fmt.Println("Received:", value)<br>
}<br>
}
主函数中启动生产者和消费者：
ch := make(chan int)<br> var wg sync.WaitGroup<br><br> wg.Add(1)<br> go producer(ch)<br> go consumer(ch, &wg)<br> wg.Wait()
避免常见并发问题
goroutine虽然方便，但也容易引发以下问题：
- 竞态条件：多个goroutine同时访问共享变量。可通过互斥锁（sync.Mutex）或channel避免。
- 死锁：goroutine相互等待导致程序挂起。确保channel的发送和接收配对，及时关闭不再使用的channel。
- 资源泄漏：goroutine一直阻塞未退出。使用context包控制超时或取消。
使用context控制goroutine生命周期：
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)<br>
defer cancel()<br><br>
go func() {<br>
select {<br>
case <-time.After(3 * time.Second):<br>
fmt.Println("Work done")<br>
case <-ctx.Done():<br>
fmt.Println("Cancelled due to timeout")<br>
}<br>
}()<br><br><-ctx.Done() // 等待上下文结束
基本上就这些。掌握goroutine、channel、WaitGroup和context的组合使用，就能写出稳定高效的并发程序。关键是理解“不要通过共享内存来通信，而应该通过通信来共享内存”这一Go并发哲学。
