Go语言实现并发控制的常见方式详解

发表于Go语言交流版块教程

在Go语言中，实现并发控制是构建高性能、响应式应用程序的关键。Go提供了多种并发控制机制，包括goroutine、channel、sync包中的锁等。以下是Go语言实现并发控制的一些常见方式的详解。1

在Go语言中，实现并发控制是构建高性能、响应式应用程序的关键。Go提供了多种并发控制机制，包括goroutine、channel、sync包中的锁等。以下是Go语言实现并发控制的一些常见方式的详解。

1. Goroutines

Goroutine是Go语言实现并发的基本单元。通过在函数调用前加上关键字go，可以创建一个新的goroutine。Goroutines由Go运行时管理，它们可以并行执行，有效地利用多核CPU。

func doSomeWork() {
    // 执行一些工作
}

func main() {
    go doSomeWork() // 创建一个goroutine
    // 主goroutine可以继续做其他事情
}

2. Channels

Channel是Go语言中的通信机制，用于在goroutines之间进行同步和异步通信。通过channel，goroutines可以发送和接收值。

type Message struct {
    Text string
}

func worker(ch <-chan Message, done chan<- bool) {
    message := <-ch // 从channel接收消息
    // 处理消息
    done <- true // 通过done channel发送完成信号
}

func main() {
    ch := make(chan Message)
    done := make(chan bool)
    go worker(ch, done)
    ch <- Message{Text: "Hello"}
    <-done // 等待worker完成
}

3. sync.Mutex

sync.Mutex提供了互斥锁，用于保护共享资源不被多个goroutine同时访问，从而避免竞态条件。

var mu sync.Mutex
var counter int

func increment() {
    mu.Lock()         // 获取锁
    defer mu.Unlock() // 释放锁
    counter++
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            increment()
            wg.Done()
        }()
    }
    wg.Wait()
    println(counter) // 输出应该是100
}

4. sync.RWMutex

sync.RWMutex是sync.Mutex的读写锁版本，它允许多个goroutine同时读取，但同一时间只允许一个goroutine写入。

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

func read(key string) string {
    rwMutex.RLock() // 读锁
    defer rwMutex.RUnlock()
    return data[key]
}

func write(key, value string) {
    rwMutex.Lock()   // 写锁
    defer rwMutex.Unlock()
    data[key] = value
}

func main() {
    // 多个goroutine可以同时读取，但写入需要等待
}

5. WaitGroup

sync.WaitGroup用于等待一组goroutine完成。WaitGroup通过计数器来跟踪等待完成的goroutine数量。

var wg sync.WaitGroup

func doWork() {
    defer wg.Done() // 标记一个goroutine完成
    // 执行工作
}

func main() {
    for i := 0; i < 5; i++ {
        wg.Add(1) // 增加等待的goroutine数量
        go doWork()
    }
    wg.Wait() // 等待所有goroutine完成
}

6. Once

sync.Once用于确保某个操作在多个goroutine中只执行一次。这对于单例模式和初始化操作非常有用。

var once sync.Once
var singleton *MyType

type MyType struct {
    // ...
}

func GetSingleton() *MyType {
    once.Do(func() {
        singleton = &MyType{
            // 初始化
        }
    })
    return singleton
}

7. Atomic

sync/atomic包提供了一系列用于执行低级原子内存操作的函数。这些操作对于实现无锁数据结构和算法非常有用。

import "sync/atomic"

var counter int64

func increment() {
    atomic.AddInt64(&counter, 1) // 原子增加
}

func main() {
    // 多个goroutine同时调用increment，counter的值仍然会正确增加
}