如何在ubuntu上使用golang的并发特性

在 Ubuntu 上玩转 Go 语言的并发特性，核心无非就是两样东西：goroutines 和 channels。下面咱们一步步把这套机制跑通，顺便搭几个典型的小例子，让你摸清门道。

安装 Golang

动手之前，先确认系统里有没有装好 Go 环境。没装的话，一条命令就能搞定：

sudo apt update
sudo apt install golang-go

装完记得验证一下：

go version

看到版本号输出，就算万事俱备了。

创建一个简单的并发程序

先来一个最基础的 goroutine 演示——让一个函数单独跑，不干扰主程序。

1. 新建文件：

   nano hello.go

2. 写入代码：

   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() // 启动一个新的 goroutine
       fmt.Println("Main function is running")
       time.Sleep(6 * time.Second) // 等待 goroutine 完成
   }

3. 运行看看效果：

   go run hello.go

你会看到 “Main function is running” 先打印出来，然后每隔一秒输出一个数字。注意主线程最后那句 time.Sleep(6 * time.Second) 是故意用来等 goroutine 跑完的——否则 main 一结束，所有 goroutine 也瞬间被掐灭。

使用 Channels 进行通信

goroutine 之间要传递数据，最正统的方式就是 channel。一个生产、一个消费，典型场景：

1. 新建文件：

   nano channels.go

2. 写入代码：

   package main
   
   import (
       "fmt"
       "time"
   )
   
   func produce(ch chan<- int) {
       for i := 1; i <= 5; i++ {
           ch <- i
           time.Sleep(1 * time.Second)
       }
       close(ch)
   }
   
   func consume(ch <-chan int) {
       for num := range ch {
           fmt.Printf("Received: %d\n", num)
       }
   }
   
   func main() {
       ch := make(chan int)
       go produce(ch)
       go consume(ch)
       time.Sleep(6 * time.Second)
   }

3. 运行：

   go run channels.go

生产者每隔一秒往 channel 里扔一个数字，消费者那边则源源不断地接收并打印。这比直接用全局变量加锁优雅得多——channel 本身自带同步，省心不少。

使用 sync.WaitGroup 进行同步

前面用 time.Sleep 等 goroutine 结束，终究是笨办法。更靠谱的做法是用 sync.WaitGroup，它能精确等待指定数量的 goroutine 全部完成。

1. 新建文件：

   nano waitgroup.go

2. 写入代码：

   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()
       fmt.Println("All goroutines are done")
   }

3. 运行：

   go run waitgroup.go

这里 wg.Add(1) 告诉 WaitGroup 要等一个 goroutine，defer wg.Done() 确保 goroutine 结束时计数器减一，最后 wg.Wait() 阻塞直到计数器归零。干净利落，再也不用猜要等几秒了。

以上几个例子基本覆盖了 Go 并发编程最常用的模式。实际项目中还可以结合 select、context 等工具做更精细的控制，但先把这三板斧练熟，大部分并发场景都能从容应对。