CentOS Golang并发编程指南

一、环境准备

1. 安装Golang

   • 通过yum安装：sudo yum install golang
   • 或手动下载安装包（如go1.20.4.linux-amd64.tar.gz），解压至/usr/local，并配置环境变量：

     echo "export PATH=$PATH:/usr/local/go/bin" >> ~/.bashrc
     source ~/.bashrc
     

   • 验证安装：go version。

2. 创建项目目录

   mkdir ~/go-concurrency-demo
   cd ~/go-concurrency-demo
   go mod init demo
   

二、基础并发编程

1. Goroutine（轻量级线程）

   • 使用go关键字启动并发任务：

     func say(msg string) {
         for i := 0; i < 3; i++ {
             fmt.Println(msg)
         }
     }
     func main() {
         go say("Hello") // 启动goroutine
         say("World")    // 主线程执行
     }
     

2. Channel（通道）

   • 用于goroutine间通信：

     func worker(id int, ch chan int) {
         for num := range ch {
             fmt.Printf("Worker %d received: %d\n", id, num)
         }
     }
     func main() {
         ch := make(chan int)
         for i := 1; i <= 3; i++ {
             go worker(i, ch)
         }
         for i := 1; i <= 5; i++ {
             ch <- i // 发送数据到通道
         }
         close(ch) // 关闭通道
     }
     

3. 同步机制

   • WaitGroup：等待一组goroutine完成

     var wg sync.WaitGroup
     wg.Add(2)
     go func() {
         defer wg.Done()
         // 任务1
     }()
     go func() {
         defer wg.Done()
         // 任务2
     }()
     wg.Wait() // 阻塞直到所有goroutine完成
     

   • Mutex：保护共享资源

     var mu sync.Mutex
     var counter int
     func increment() {
         mu.Lock()
         counter++
         mu.Unlock()
     }
     

三、进阶并发模式

1. 生产者-消费者模式

   func producer(ch chan int) {
       for i := 1; i <= 5; i++ {
           ch <- i
       }
       close(ch)
   }
   func consumer(ch chan int) {
       for num := range ch {
           fmt.Println("Consumed:", num)
       }
   }
   func main() {
       ch := make(chan int)
       go producer(ch)
       go consumer(ch)
   }
   

2. 扇出/扇入模式

   • 扇出：多个goroutine并行处理任务；扇入：合并结果。

     func process(input int, ch chan int) {
         ch <- input * 2
     }
     func main() {
         inputs := []int{1, 2, 3, 4}
         ch := make(chan int)
         // 扇出：启动多个goroutine处理
         for _, v := range inputs {
             go process(v, ch)
         }
         // 扇入：合并结果
         for i := 0; i < len(inputs); i++ {
             fmt.Println(<-ch)
         }
     }
     

四、调试与优化

1. 检测数据竞争

   go run -race main.go
   

2. 性能分析

   • 启用pprof：

     import _ "net/http/pprof"
     // 在代码中启动HTTP服务
     go func() {
         log.Println(http.ListenAndServe("localhost:6060", nil))
     }()
     

   • 使用go tool pprof分析：

     go tool pprof http://localhost:6060/debug/pprof/profile
     

五、注意事项

• 避免过度创建goroutine：通过sync.WaitGroup或goroutine池控制并发数量。
• 合理使用通道：无缓冲通道用于同步，有缓冲通道用于异步。
• 上下文管理：使用context.Context传递取消信号或超时控制。

参考资料：