Go 语言（Golang）并发编程通俗易懂案例

Go 语言（Golang）天生支持并发编程，它的并发模型基于轻量级的 goroutine 和通信顺序进程（CSP）的思想。Goroutine 是 Go 语言中的并发执行单元，通过通道（channel）来实现不同 goroutine 之间的通信。

以下是一些关于 Golang 并发编程的重要概念和案例：

1. Goroutine 和 Channel

Goroutine 是 Go 语言中的轻量级线程，可以理解为一种并发执行的函数。Channel 是用于在 goroutine 之间传递数据的数据结构。

案例：计算并发 Fibonacci 数列

package main

import "fmt"

func fibonacci(n int, c chan int) {
    a, b := 0, 1
    for i := 0; i < n; i++ {
        c <- a
        a, b = b, a+b
    }
    close(c)
}

func main() {
    n := 10
    c := make(chan int)
    go fibonacci(n, c)

    for value := range c {
        fmt.Println(value)
    }
}

2. WaitGroup

sync.WaitGroup 是一个计数信号量，用于等待一组 goroutine 执行完成。当计数不为零时，调用 Wait 将会阻塞。

案例：使用 WaitGroup 等待多个 goroutine 完成

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    wg.Wait()
    fmt.Println("All workers done.")
}

3. Mutex 和互斥锁

sync.Mutex 是 Golang 提供的一种互斥锁，用于在多个 goroutine 之间保护共享资源。

案例：使用 Mutex 保护共享资源

package main

import (
    "fmt"
    "sync"
)

var counter int
var mu sync.Mutex

func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    mu.Lock()
    counter++
    mu.Unlock()
}

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go increment(&wg)
    }

    wg.Wait()
    fmt.Println("Counter:", counter)
}

这里的 counter 是一个共享资源，使用互斥锁保护，确保在并发修改时不会发生数据竞争。

这些案例展示了 Golang 中的一些基本并发编程概念，包括 goroutine、channel、WaitGroup、Mutex 等。在实际应用中，这些工具和概念可以帮助你更方便地实现并发编程，并充分利用多核处理器的优势。