在Go语言中，说起并发控制，最核心的无外乎 goroutines 和 channels 这对搭档。goroutines 可以理解为轻量级的线程，能让你在程序中同时跑多个任务，而 channels 则负责在它们之间传递数据和同步协调。下面就在 Ubuntu 环境下，用几个实际例子来拆解 Go 的并发控制思路。
用 go 关键字启动一个 goroutine
最直接的方式——在函数调用前加上 go，这个函数就会在新 goroutine 里跑。但要注意，主函数不会等待它执行完毕，所以通常需要加一点延时才能看到效果。
package main
import (
"fmt"
"time"
)
func printNumbers() {
for i := 1; i <= 5; i++ {
fmt.Printf("Number: %d\n", i)
time.Sleep(1 * time.Second)
}
}
func main() {
go printNumbers()
time.Sleep(6 * time.Second)
}用 sync.WaitGroup 优雅地等待所有 goroutine 结束
真实场景下不可能靠 time.Sleep 来硬等。标准库的 sync.WaitGroup 就是干这个的：每启动一个 goroutine 就调用 wg.Add(1)，任务完成后用 wg.Done() 通知，最后通过 wg.Wait() 阻塞直到所有任务收工。
package main
import (
"fmt"
"sync"
"time"
)
func printNumbers(wg *sync.WaitGroup) {
defer wg.Done()
for i := 1; i <= 5; i++ {
fmt.Printf("Number: %d\n", i)
time.Sleep(1 * time.Second)
}
}
func main() {
var wg sync.WaitGroup
wg.Add(1)
go printNumbers(&wg)
wg.Wait()
}用 channel 在 goroutines 之间传递数据
如果多个 goroutine 需要互相通信，channel 是最自然的桥梁。下面例子先往带缓冲的 chan 里塞入 5 个数字，然后关闭 channel，再启动一个 goroutine 去接收并打印它们——这种“生产者-消费者”模式在并发编程中非常常见。
package main
import (
"fmt"
"time"
)
func printNumbers(numbers chan int) {
for num := range numbers {
fmt.Printf("Number: %d\n", num)
time.Sleep(1 * time.Second)
}
}
func main() {
numbers := make(chan int, 5)
for i := 1; i <= 5; i++ {
numbers <- i
}
close(numbers)
go printNumbers(numbers)
time.Sleep(6 * time.Second)
}用 sync.Mutex 保护共享资源
当多个 goroutine 同时读写同一个变量时（比如计数器），数据竞争在所难免。这时候就需要一把互斥锁来保证同一时刻只有一个 goroutine 能操作共享数据。下面代码启动 10 个 goroutine 并发递增 counter，通过 sync.Mutex 确保最终结果正确。
package main
import (
"fmt"
"sync"
"time"
)
var counter int
var mutex sync.Mutex
func incrementCounter() {
mutex.Lock()
defer mutex.Unlock()
counter++
}
func main() {
wg := sync.WaitGroup{}
for i := 0; i < 10; i++ {
wg.Add(1)
go func() {
defer wg.Done()
incrementCounter()
}()
}
wg.Wait()
fmt.Printf("Counter: %d\n", counter)
}这几个例子覆盖了 Go 并发控制中最基础也最实用的套路：直接启动 goroutine、用 WaitGroup 统一等待、用 channel 做通信、用 Mutex 保护临界区。根据实际场景选对工具，并发代码就能写得既清晰又安全。
