【go语言】3.2.3 sync 包的使用

Go 语言的 sync 包提供了一些基本的同步原语，如互斥锁（Mutex）和等待组（WaitGroup）。这些原语可以帮助你在多个 Go Routine 之间同步状态。

Mutex

互斥锁是一种同步工具，用于保证多个 Go Routine 在访问共享资源时的互斥性。

创建 Mutex：

var m sync.Mutex

使用 Mutex：

m.Lock()
// 临界区，只有获得锁的 Go Routine 才能访问
m.Unlock()

例如，假设我们有一个计数器## sync 包的使用

Go 语言的 sync 包提供了一些基本的同步原语，如互斥锁（Mutex）和等待组（WaitGroup）。这些原语可以帮助你在多个 Go Routine 之间同步状态。

Mutex

互斥锁是一种同步工具，用于保证多个 Go Routine 在访问共享资源时的互斥性。

创建 Mutex：

var m sync.Mutex

使用 Mutex：

m.Lock()
// 临界区，只有获得锁的 Go Routine 才能访问
m.Unlock()

例如，假设我们有一个计数器，我们希望它能在多个 Go Routine 之间安全地使用：

package main

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

type SafeCounter struct {
    v   map[string]int
    mux sync.Mutex
}

func (c *SafeCounter) Inc(key string) {
    c.mux.Lock()
    c.v[key]++
    c.mux.Unlock()
}

func (c *SafeCounter) Value(key string) int {
    c.mux.Lock()
    defer c.mux.Unlock()
    return c.v[key]
}

func main() {
    c := SafeCounter{v: make(map[string]int)}
    for i := 0; i < 1000; i++ {
        go c.Inc("somekey")
    }

    time.Sleep(time.Second)
    fmt.Println(c.Value("somekey"))
}

在这个例子中，SafeCounter 的每个方法在操作 v 之前都会锁定 Mutex 来确保安全访问。

WaitGroup

WaitGroup 是用于等待一组 Go Routines 完成的结构。

使用 WaitGroup：

var wg sync.WaitGroup

每次一个 Go Routine 启动时，我们调用 wg.Add(1)。每次一个 Go Routine 完成时，我们调用 wg.Done()。我们可以使用 wg.Wait() 来阻塞，直到所有的 Go Routines 完成。

例如，假设我们启动了多个 Go Routine 来完成一些工作，我们希望等待它们全部完成：

package main

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

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()

    fmt.Printf("Worker %d starting\n", id)

    time.Sleep(time.Second)
    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()
}

在这个例子中，我们使用 WaitGroup 来等待 5 个 worker Go Routines 完成。

总的来说，Go 语言的 sync 包提供了互斥锁和等待组等同步原语，它们可以帮助我们在多个 Go Routine 之间同步状态。虽然 Go 语言的并发模型主要是基于 Channels 的，但在某些情况下，使用 sync 包提供的同步原语可能会更加方便或有效。
推荐阅读：

https://mp.weixin.qq.com/s/dV2JzXfgjDdCmWRmE0glDA

https://mp.weixin.qq.com/s/an83QZOWXHqll3SGPYTL5g