Go语言并发编程实战：从入门到精通

一、问题/场景描述

在开发高性能网络服务或数据处理程序时，开发者常常面临如何有效利用多核CPU资源、避免程序阻塞、提升系统吞吐量的挑战。Go语言以其原生的并发模型，为这类问题提供了优雅且高效的解决方案。

二、原因分析

传统多线程编程模型（如Java、C++）通常基于操作系统线程，存在创建成本高、上下文切换开销大、同步机制复杂（如锁）易导致死锁等问题。Go语言则通过“goroutine”和“channel”重新定义了并发。Goroutine是轻量级用户态线程，由Go运行时调度，创建和切换开销极小。Channel则是goroutine间通信的首选方式，遵循“不要通过共享内存来通信，而应通过通信来共享内存”的原则，从设计上降低了数据竞争和锁的复杂度，使得编写安全、高效的并发程序变得更加直观。

三、详细解决步骤

步骤1：创建并启动Goroutine

使用关键字 go 即可启动一个goroutine来并发执行函数。

package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 3; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    // 在主goroutine中执行
    go say("world")
    // 启动一个新的goroutine并发执行
    say("hello")
    // 等待一会儿，确保goroutine有机会执行
    time.Sleep(time.Second)
}

步骤2：使用Channel进行通信与同步

Channel是类型化的管道，用于在goroutine之间传递数据和同步执行。

package main

import "fmt"

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // 将结果发送到channel c
}

func main() {
    s := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // 从channel c接收结果（此处会阻塞等待）

    fmt.Println(x, y, x+y)
}

步骤3：使用Select处理多个Channel

select 语句让一个goroutine可以等待多个通信操作，类似于 switch，但每个case是一个channel操作。

package main

import (
    "fmt"
    "time"
)

func main() {
    tick := time.Tick(100 * time.Millisecond)
    boom := time.After(500 * time.Millisecond)
    for {
        select {
        case <-tick:
            fmt.Println("滴答.")
        case <-boom:
            fmt.Println("轰！")
            return
        default:
            // 当其他case都不ready时执行
            fmt.Println("    .")
            time.Sleep(50 * time.Millisecond)
        }
    }
}

步骤4：使用sync包进行低级同步

对于更复杂的控制，如等待一组goroutine完成，可以使用 sync.WaitGroup。

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 通知WaitGroup此goroutine已完成
    fmt.Printf("Worker %d starting ", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d done ", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1) // 为每个goroutine增加计数
        go worker(i, &wg)
    }

    wg.Wait() // 阻塞，直到所有goroutine都调用了Done()
    fmt.Println("All workers completed")
}

四、注意事项

使用Go并发时需注意：避免在goroutine中直接修改共享变量，应通过channel传递；注意channel的关闭和遍历，向已关闭的channel发送数据会引发panic；合理使用带缓冲的channel；使用 context 包来管理goroutine的生命周期和取消操作，防止goroutine泄漏。

五、适用环境

适用于需要构建高并发、高性能的后端服务、网络爬虫、实时数据处理系统等场景。