（转）5000字带你精通golang sync包的所有姿势

原文：https://blog.csdn.net/bactcolor/article/details/131608685

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
上面的代码中，我们定义了一个全局变量data，用来存储一个整数。我们启动了10个goroutine，其中偶数序号的goroutine都调用writeData()函数来对data进行写操作，奇数序号的goroutine都调用readData()函数来对data进行读操作。为了保证data的正确性和并发性能，我们在writeData()函数中使用了sync.RWMutex{}来加写锁和解写锁，在readData()函数中使用了sync.RWMutex{}来加读锁和解读锁。这样就可以允许多个goroutine同时读取data，但是只有一个goroutine可以修改data。

三、sync.Once{}
sync.Once{}是一个只执行一次的对象，它可以保证在多个goroutine中，某个函数或代码块只被执行一次。我们可以使用Do()方法来传入要执行的函数。例如：

var once sync.Once

func initConfig() {
fmt.Println("init config")
}

func main() {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func() {
defer wg.Done()
once.Do(initConfig) // 只执行一次
}()
}
wg.Wait()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
上面的代码中，我们定义了一个全局变量once，用来控制initConfig()函数只被执行一次。我们启动了10个goroutine，每个goroutine都调用once.Do(initConfig)来尝试执行initConfig()函数。但是由于once的保证，只有第一个goroutine能够成功执行initConfig()函数，后面的goroutine都会被忽略。这样就可以避免重复初始化或资源浪费的问题。

四、sync.Pool{}
sync.Pool{}是一个临时对象池，它可以缓存一些可重用的对象，以减少内存分配和垃圾回收的开销。我们可以使用New字段来指定对象的创建方式，以及Get()和Put()方法来获取和归还对象。例如：

type Data struct {
Content string
}

var pool = sync.Pool{
New: func() interface{} {
return &Data{} // 创建对象的方式
},
}

func main() {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
data := pool.Get().(*Data) // 获取对象
defer pool.Put(data) // 归还对象
data.Content = fmt.Sprintf("data %d", i) // 修改对象
fmt.Println(data.Content) // 输出对象
}(i)
}
wg.Wait()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
上面的代码中，我们定义了一个全局变量pool，用来缓存Data类型的对象。我们启动了10个goroutine，每个goroutine都从pool中获取一个Data对象，修改它的Content字段，然后输出它的内容，最后归还给pool。这样就可以避免每次都创建和销毁Data对象，提高性能和内存利用率。

五、sync.Map{}
sync.Map{}是一个并发安全的映射，它可以在多个goroutine中存储和读取键值对。我们可以使用Store()、Load()、Delete()、Range()等方法来操作映射。例如：

var m sync.Map

func main() {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
m.Store(i, i*i) // 存储键值对
}(i)
}
wg.Wait()
m.Range(func(key, value interface{}) bool {
fmt.Println(key, value) // 遍历映射
return true
})
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
上面的代码中，我们定义了一个全局变量m，用来存储整数和其平方的映射。我们启动了10个goroutine，每个goroutine都向m中存储一个键值对。然后我们使用m.Range()方法来遍历m中的所有键值对，并输出它们。这样就可以避免使用普通的map时需要加锁的问题，提高并发性能。

六、sync.Cond{}
sync.Cond{}是一个条件变量，它可以让一组goroutine在满足某个条件时被唤醒。我们可以使用NewCond()函数来创建一个条件变量，并传入一个互斥锁作为参数。我们还可以使用Wait()、Signal()、Broadcast()等方法来等待、单发通知、广播通知等。例如：

var queue []int
var mu sync.Mutex
var cond = sync.NewCond(&mu)

func produce(i int) {
mu.Lock() // 加锁
defer mu.Unlock() // 延迟解锁
queue = append(queue, i) // 生产数据
fmt.Println("produce:", i)
cond.Signal() // 通知一个消费者
}

func consume(i int) {
mu.Lock() // 加锁
for len(queue) == 0 { // 如果队列为空
cond.Wait() // 等待生产者通知
}
data := queue[0] // 消费数据
queue = queue[1:]
mu.Unlock() // 解锁
fmt.Println("consume:", i, data)
}

func main() {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
produce(i) // 生产数据
}(i)
}
for i := 0; i < 10; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
consume(i) // 消费数据
}(i)
}
wg.Wait()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
上面的代码中，我们定义了一个全局变量queue，用来存储一些整数。我们还定义了一个全局变量cond，用来创建一个条件变量，并传入一个互斥锁mu作为参数。我们启动了10个生产者goroutine和10个消费者goroutine，每个生产者goroutine都调用produce()函数来向queue中添加一个整数，并使用cond.Signal()方法来通知一个消费者goroutine；每个消费者goroutine都调用consume()函数来从queue中取出一个整数，并使用cond.Wait()方法来等待生产者goroutine的通知。这样就可以实现一个简单的生产者-消费者模型，避免队列为空或满时的阻塞问题。

七、总结
golang并发编程中sync包提供了一些高性能的同步原语，可以帮助我们更好地管理并发状态和资源。