go sync包中的互斥锁Mutex和等待组WaitGroup使用详解
作者：移动安全星球
Go 语言的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 包提供的同步原语可能会更加方便或有效。
以上就是go sync包中的互斥锁Mutex和等待组WaitGroup使用详解的详细内容，更多关于go sync包互斥锁等待组的资料请关注脚本之家其它相关文章！