Linux Golang如何进行并发控制

在Golang的并发编程世界里，goroutines和channels是两大基石。goroutines可以看作是轻量级的线程，让你在同一程序里同时跑多个任务；而channels则负责在它们之间传递数据、同步操作。说白了，这就是Go语言为并发准备的“乐高积木”。

那么，具体怎么玩转并发控制？下面这几种方法，基本覆盖了日常开发中最常见的场景：

1. 用sync.WaitGroup等待一组goroutines收工——相当于给所有并发任务发一个“集合号”，等它们都跑完了再继续往下走。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            fmt.Printf("Goroutine %d\n", i)
        }(i)
    }
    wg.Wait()
    fmt.Println("All goroutines finished")
}

2. 用sync.Mutex实现互斥锁——当多个goroutines要同时修改一个共享变量时，就得靠它来“排好队，一个一个来”，防止数据打架。

package main

import (
    "fmt"
    "sync"
)

var counter int
var mutex sync.Mutex

func increment() {
    mutex.Lock()
    defer mutex.Unlock()
    counter++
}

func main() {
    wg := sync.WaitGroup{}
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            increment()
        }()
    }
    wg.Wait()
    fmt.Println("Counter:", counter)
}

3. 用sync.RWMutex实现读写锁——读多写少的场景下，这个锁更高效：允许同时多个goroutines读数据，但写的时候必须独占，谁也别来打扰。

package main

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

var data map[string]string
var rwMutex sync.RWMutex

func readData(key string) {
    rwMutex.RLock()
    defer rwMutex.RUnlock()
    value := data[key]
    fmt.Printf("Read %s: %s\n", key, value)
}

func writeData(key, value string) {
    rwMutex.Lock()
    defer rwMutex.Unlock()
    data[key] = value
    fmt.Printf("Write %s: %s\n", key, value)
}

func main() {
    data = make(map[string]string)
    wg := sync.WaitGroup{}
    wg.Add(1)
    go func() {
        defer wg.Done()
        writeData("key1", "value1")
    }()
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            key := fmt.Sprintf("key%d", i)
            readData(key)
        }(i)
    }
    wg.Wait()
}

4. 用sync.Cond实现条件变量——当某个条件不满足时，让goroutines“先睡一觉”，等条件成熟了再统一唤醒。典型的生产者-消费者模式就常用这个。

package main

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

var cond = sync.NewCond(&sync.Mutex{})
var ready bool

func worker(id int) {
    cond.L.Lock()
    for !ready {
        cond.Wait()
    }
    fmt.Printf("Worker %d started\n", id)
    cond.L.Unlock()
}

func main() {
    for i := 0; i < 5; i++ {
        go worker(i)
    }
    time.Sleep(1 * time.Second)
    cond.L.Lock()
    ready = true
    cond.Broadcast()
    cond.L.Unlock()
    time.Sleep(1 * time.Second)
}

以上四种方法，基本能应对Golang并发编程中绝大多数场景。选择哪种，取决于你的具体需求——是等待任务完成、保护共享资源、还是协调条件触发。记住一点：用锁和同步原语时，一定要小心谨慎，避免死锁和竞态条件。毕竟，并发虽好，翻车也快。?