在Golang中实现多协程并发执行非常简单，主要依赖于 goroutine 和 channel 配合同步机制。下面介绍几种常用方式，帮助你高效地启动多个协程并管理它们的执行。

1. 基础：使用 goroutine 启动并发任务

Goroutine 是轻量级线程，由 Go 运行时调度。通过 go 关键字即可启动一个协程。

package main
<p>import (
"fmt"
"time"
)</p><p>func task(id int) {
fmt.Printf("任务 %d 开始执行\n", id)
time.Sleep(1 * time.Second)
fmt.Printf("任务 %d 执行完成\n", id)
}</p><p>func main() {
for i := 1; i <= 3; i++ {
go task(i)
}</p><pre class="brush:php;toolbar:false;">// 等待所有协程完成（临时方案）
time.Sleep(2 * time.Second)

}

Golang Uber Dig

使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等

下载

注意：main 函数不会等待协程结束，所以需要阻塞主线程（如使用 Sleep），但这不推荐用于生产环境。

立即学习“go语言免费学习笔记（深入）”；

2. 推荐：使用 sync.WaitGroup 控制协程同步

WaitGroup 可以等待一组协程完成，是控制并发的常用方式。

package main
<p>import (
"fmt"
"sync"
"time"
)</p><p>func worker(id int, wg *sync.WaitGroup) {
defer wg.Done() // 任务完成，计数器减一
fmt.Printf("协程 %d 开始工作\n", id)
time.Sleep(time.Second)
fmt.Printf("协程 %d 完成\n", id)
}</p><p>func main() {
var wg sync.WaitGroup</p><pre class="brush:php;toolbar:false;">for i := 1; i <= 5; i++ {
    wg.Add(1)           // 计数器加一
    go worker(i, &wg)
}

wg.Wait() // 阻塞，直到所有协程调用 Done()
fmt.Println("所有协程执行完毕")

}

3. 使用 channel 进行协程间通信与结果收集

如果需要获取协程的执行结果，可以使用 channel 来传递数据。

package main
<p>import (
"fmt"
"sync"
)</p><p>func fetchData(id int, ch chan string) {
// 模拟耗时操作
result := fmt.Sprintf("数据 %d 获取完成", id)
ch <- result
}</p><p>func main() {
resultCh := make(chan string, 5) // 缓冲 channel
var wg sync.WaitGroup</p><pre class="brush:php;toolbar:false;">for i := 1; i <= 5; i++ {
    wg.Add(1)
    go func(i int) {
        defer wg.Done()
        fetchData(i, resultCh)
    }(i)
}

// 协程结束后关闭 channel
go func() {
    wg.Wait()
    close(resultCh)
}()

// 从 channel 中读取结果
for result := range resultCh {
    fmt.Println(result)
}

}

4. 控制并发数量：使用带缓冲的 channel 实现协程池

当协程数量过多时，可以通过信号量模式限制并发数。

package main
<p>import (
"fmt"
"sync"
"time"
)</p><p>func workerWithLimit(id int, sem chan struct{}, wg *sync.WaitGroup) {
defer wg.Done()</p><pre class="brush:php;toolbar:false;">sem <- struct{}{} // 获取信号量
fmt.Printf("协程 %d 开始执行\n", id)
time.Sleep(500 * time.Millisecond)
fmt.Printf("协程 %d 执行结束\n", id)
<-sem // 释放信号量

}

func main() { const maxConcurrency = 3 sem := make(chan struct{}, maxConcurrency) // 最多允许 3 个并发 var wg sync.WaitGroup

for i := 1; i <= 10; i++ {
    wg.Add(1)
    go workerWithLimit(i, sem, &wg)
}

wg.Wait()
fmt.Println("所有任务完成")

}

这种方式能有效避免资源耗尽，适用于大量任务但需限制同时运行数量的场景。

基本上就这些。掌握 goroutine、WaitGroup、channel 和并发控制技巧，就能灵活实现各种并发需求。关键是避免竞态条件，合理同步和传递数据。不复杂但容易忽略细节。