Go 语言的 sync 包提供了基本的同步原语，用于在并发编程中协调 goroutine 之间的操作。

1. 互斥锁 (Mutex)

互斥锁用于保护共享资源，确保同一时间只有一个 goroutine 可以访问。
特点：

• 最基本的同步原语，实现互斥访问共享资源
  
• 有两个方法：
  1. Lock()

  复制代码
  和
  1. Unlock()

  复制代码
• 不可重入，同一个 goroutine 重复获取会导致死锁
  
• 没有超时机制，锁定后必须等待解锁
  
• 不区分读写操作，所有操作都是互斥的
  
• 适用于共享资源竞争不激烈的场景
  
• 性能高于 channel 实现的互斥机制
  
• 不保证公平性，可能导致饥饿问题
  

1. import (
   
2.     "fmt"
   
3.     "sync"
   
4.     "time"
   
5. )
   
6. 
   
7. func main() {
   
8.     var mutex sync.Mutex
   
9.     counter := 0
   
10.    
    
11.     for i := 0; i < 1000; i++ {
    
12.         go func() {
    
13.             mutex.Lock()
    
14.             defer mutex.Unlock()
    
15.             counter++
    
16.         }()
    
17.     }
    
18.    
    
19.     time.Sleep(time.Second)
    
20.     fmt.Println("计数器:", counter)
    
21. }

复制代码

2. 读写锁 (RWMutex)

当多个 goroutine 需要读取而很少写入时，读写锁比互斥锁更高效。
特点：

• 针对读多写少场景优化的锁
  
• 提供四个方法：
  1. RLock()

  复制代码
  、
  1. RUnlock()

  复制代码
  、
  1. Lock()

  复制代码
  、
  1. Unlock()

  复制代码
• 允许多个读操作并发进行，但写操作是互斥的
  
• 写锁定时，所有读操作都会被阻塞
  
• 有读锁定时，写操作会等待所有读操作完成
  
• 写操作优先级较高，防止写饥饿
  
• 内部使用 Mutex 实现
  
• 比 Mutex 有更多开销，但在读多写少场景下性能更高
  

1. var rwMutex sync.RWMutex
   
2. var data map[string]string = make(map[string]string)
   
3. 
   
4. // 读取操作
   
5. func read(key string) string {
   
6.     rwMutex.RLock()
   
7.     defer rwMutex.RUnlock()
   
8.     return data[key]
   
9. }
   
10. 
    
11. // 写入操作
    
12. func write(key, value string) {
    
13.     rwMutex.Lock()
    
14.     defer rwMutex.Unlock()
    
15.     data[key] = value
    
16. }

复制代码

3. 等待组 (WaitGroup)

等待组用于等待一组 goroutine 完成执行。
特点：

• 用于协调多个 goroutine 的完成
  
• 提供三个方法：
  1. Add()

  复制代码
  、
  1. Done()

  复制代码
  、
  1. Wait()

  复制代码
• 1. Add()

  复制代码
  增加计数器，参数可为负数
  
• 1. Done()

  复制代码
  等同于
  1. Add(-1)

  复制代码
  ，减少计数器
  
• 1. Wait()

  复制代码
  阻塞直到计数器归零
  
• 计数器不能变为负数，会导致 panic
  
• 可以重用，计数器归零后可以再次增加
  
• 非常适合"扇出"模式（启动多个工作 goroutine 并等待全部完成）
  
• 不包含工作内容信息，仅表示完成状态
  
• 轻量级，开销很小
  

1. func main() {
   
2.     var wg sync.WaitGroup
   
3.    
   
4.     for i := 0; i < 5; i++ {
   
5.         wg.Add(1) // 增加计数器
   
6.         go func(id int) {
   
7.             defer wg.Done() // 完成时减少计数器
   
8.             fmt.Printf("工作 %d 完成\n", id)
   
9.         }(i)
   
10.     }
    
11.    
    
12.     wg.Wait() // 等待所有 goroutine 完成
    
13.     fmt.Println("所有工作已完成")
    
14. }

复制代码

4. 一次性执行 (Once)

Once 确保一个函数只执行一次，无论有多少 goroutine 尝试执行它。
特点：

• 确保某个函数只执行一次
  
• 只有一个方法：
  1. Do(func())

  复制代码
• 即使在多个 goroutine 中调用也只执行一次
  
• 常用于单例模式或一次性初始化
  
• 内部使用互斥锁和一个标志位实现
  
• 非常轻量级，几乎没有性能开销
  
• 如果传入的函数 panic，视为已执行
  
• 不能重置，一旦执行就不能再次执行
  
• 传入不同的函数也不会再次执行
  

1. var once sync.Once
   
2. var instance *singleton
   
3. 
   
4. func getInstance() *singleton {
   
5.     once.Do(func() {
   
6.         instance = &singleton{}
   
7.     })
   
8.     return instance
   
9. }

复制代码

5. 条件变量 (Cond)

条件变量用于等待或宣布事件的发生。
特点：

• 用于等待或通知事件发生
  
• 需要与互斥锁结合使用：
  1. sync.NewCond(&mutex)

  复制代码
• 提供三个方法：
  1. Wait()

  复制代码
  、
  1. Signal()

  复制代码
  、
  1. Broadcast()

  复制代码
• 1. Wait()

  复制代码
  自动解锁并阻塞，被唤醒后自动重新获取锁
  
• 1. Signal()

  复制代码
  唤醒一个等待的 goroutine
  
• 1. Broadcast()

  复制代码
  唤醒所有等待的 goroutine
  
• 适合生产者-消费者模式
  
• 可以避免轮询，提高性能
  
• 使用相对复杂，容易出错
  
• 等待必须在获取锁后调用
  

1. var mutex sync.Mutexvar cond = sync.NewCond(&mutex)var ready boolfunc main() {    go producer()        // 消费者    mutex.Lock()    for !ready {        cond.Wait() // 等待条件变为真    }    fmt.Println("数据已准备好")    mutex.Unlock()}func producer() {    time.Sleep(time.Second) // 模拟工作        mutex.Lock()    ready = true    cond.Signal() // 通知一个等待的 goroutine    // 或使用 cond.Broadcast() 通知所有等待的 goroutine    mutex.Unlock()}

复制代码

6. 原子操作 (atomic)

对于简单的计数器或标志，可以使用原子操作包而不是互斥锁。
特点：

• 底层的原子操作，无锁实现
  
• 适用于简单的计数器或标志位
  
• 比互斥锁性能更高，开销更小
  
• 提供多种原子操作：
  1. Add

  复制代码
  、
  1. Load

  复制代码
  、
  1. Store

  复制代码
  、
  1. Swap

  复制代码
  、
  1. CompareAndSwap

  复制代码
• 支持多种数据类型：int32、int64、uint32、uint64、uintptr 和指针
  
• 可用于实现自己的同步原语
  
• 不适合复杂的共享状态
  
• 在多 CPU 系统上可能导致缓存一致性开销
  
• Go 1.19 引入了新的原子类型
  

1. import (
   
2.     "fmt"
   
3.     "sync/atomic"
   
4.     "time"
   
5. )
   
6. 
   
7. func main() {
   
8.     var counter int64 = 0
   
9.    
   
10.     for i := 0; i < 1000; i++ {
    
11.         go func() {
    
12.             atomic.AddInt64(&counter, 1)
    
13.         }()
    
14.     }
    
15.    
    
16.     time.Sleep(time.Second)
    
17.     fmt.Println("计数器:", atomic.LoadInt64(&counter))
    
18. }

复制代码

7. Map (sync.Map)

Go 1.9 引入的线程安全的 map。
特点：

• Go 1.9 引入的线程安全的哈希表
  
• 无需额外加锁即可安全地并发读写
  
• 提供五个方法：
  1. Store

  复制代码
  、
  1. Load

  复制代码
  、
  1. LoadOrStore

  复制代码
  、
  1. Delete

  复制代码
  、
  1. Range

  复制代码
• 内部使用分段锁和原子操作优化性能
  
• 适用于读多写少的场景
  
• 不保证遍历的顺序
  
• 不支持获取元素数量或判断是否为空
  
• 不能像普通 map 那样直接使用下标语法
  
• 性能比加锁的普通 map 更好，但单线程下比普通 map 慢
  
• 内存开销较大
  

1. var m sync.Map
   
2. 
   
3. func main() {
   
4.     // 存储键值对
   
5.     m.Store("key1", "value1")
   
6.     m.Store("key2", "value2")
   
7.    
   
8.     // 获取值
   
9.     value, ok := m.Load("key1")
   
10.     if ok {
    
11.         fmt.Println("找到键:", value)
    
12.     }
    
13.    
    
14.     // 如果键不存在则存储
    
15.     m.LoadOrStore("key3", "value3")
    
16.    
    
17.     // 删除键
    
18.     m.Delete("key2")
    
19.    
    
20.     // 遍历所有键值对
    
21.     m.Range(func(key, value interface{}) bool {
    
22.         fmt.Println(key, ":", value)
    
23.         return true // 返回 false 停止遍历
    
24.     })
    
25. }

复制代码

8. Pool (sync.Pool)

对象池用于重用临时对象，减少垃圾回收压力。
特点：

• 用于缓存临时对象，减少垃圾回收压力
  
• 提供两个方法：
  1. Get()

  复制代码
  和
  1. Put()

  复制代码
• 需要提供
  1. New

  复制代码
  函数来创建新对象
  
• 对象可能在任何时候被垃圾回收，不保证存活
  
• 在 GC 发生时会清空池中的所有对象
  
• 不适合管理需要显式关闭的资源（如文件句柄）
  
• 适合于频繁创建和销毁的对象
  
• 没有大小限制，Put 总是成功的
  
• 每个 P（处理器）有自己的本地池，减少竞争
  
• Go 1.13 后大幅提升了性能
  

1. var bufferPool = sync.Pool{
   
2.     New: func() interface{} {
   
3.         return new(bytes.Buffer)
   
4.     },
   
5. }
   
6. 
   
7. func process() {
   
8.     // 获取缓冲区
   
9.     buffer := bufferPool.Get().(*bytes.Buffer)
   
10.     buffer.Reset() // 清空以便重用
    
11.    
    
12.     // 使用缓冲区
    
13.     buffer.WriteString("hello")
    
14.    
    
15.     // 操作完成后放回池中
    
16.     bufferPool.Put(buffer)
    
17. }

复制代码

9. 综合示例

下面是一个综合示例，展示了多个同步原语的使用：

1. package main
   
2. 
   
3. import (
   
4.     "fmt"
   
5.     "sync"
   
6.     "time"
   
7. )
   
8. 
   
9. type SafeCounter struct {
   
10.     mu sync.Mutex
    
11.     wg sync.WaitGroup
    
12.     count int
    
13. }
    
14. 
    
15. func main() {
    
16.     counter := SafeCounter{}
    
17.    
    
18.     // 启动 5 个 goroutine 增加计数器
    
19.     for i := 0; i < 5; i++ {
    
20.         counter.wg.Add(1)
    
21.         go func(id int) {
    
22.             defer counter.wg.Done()
    
23.             
    
24.             for j := 0; j < 10; j++ {
    
25.                 counter.mu.Lock()
    
26.                 counter.count++
    
27.                 fmt.Printf("Goroutine %d: 计数器 = %d\n", id, counter.count)
    
28.                 counter.mu.Unlock()
    
29.                
    
30.                 // 模拟工作
    
31.                 time.Sleep(100 * time.Millisecond)
    
32.             }
    
33.         }(i)
    
34.     }
    
35.    
    
36.     // 等待所有 goroutine 完成
    
37.     counter.wg.Wait()
    
38.     fmt.Println("最终计数:", counter.count)
    
39. }

复制代码

最佳实践

• 使用 defer 解锁：确保即使发生错误也能解锁
  1. mu.Lock()
     
  2. defer mu.Unlock()

  复制代码
• 避免锁的嵌套：容易导致死锁
  
• 保持临界区简短：锁定时间越短越好
  
• 基准测试比较：
  
  
  
  • 对于大多数简单操作，atomic 比 Mutex 快
    
  • RWMutex 在读操作远多于写操作时优于 Mutex
    
  • sync.Map 在高并发下比加锁的 map 性能更好
    
  
  
• 内存对齐：
  
  
  
  • 原子操作需要内存对齐
    
  • 不正确的内存对齐会严重影响性能
    
  • 特别是在 32 位系统上使用 64 位原子操作
    
  
  
• 超时控制：
  1. ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
     
  2. defer cancel()
     
  3. 
     
  4. done := make(chan struct{})
     
  5. go func() {
     
  6.     // 执行可能耗时的操作
     
  7.     mu.Lock()
     
  8.     // ...
     
  9.     mu.Unlock()
     
  10.    
      
  11.     done <- struct{}{}
      
  12. }()
      
  13. 
      
  14. select {
      
  15. case <-done:
      
  16.     // 操作成功完成
      
  17. case <-ctx.Done():
      
  18.     // 操作超时
      
  19. }

  复制代码

总结

到此这篇关于Go语言中sync包使用方法的文章就介绍到这了,更多相关Go语言sync包使用内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：互联网
免责声明：如果侵犯了您的权益，请联系站长（1277306191@qq.com），我们会及时删除侵权内容，谢谢合作！