Go并发同步核心库：syn 包深度指南

在 Go 语言中，并发是最重要的特性之一。通过 goroutine 可以轻松启动成千上万个并发任务，但随之而来的问题是：如何安全地共享数据、控制执行顺序以及避免竞态条件 。这正是 sync 包存在的意义。

sync 是 Go 标准库中用于 并发控制与同步 的核心工具，它提供了一系列原语（primitives），用于协调多个 goroutine 之间的执行关系。常见组件包括：Mutex、RWMutex、WaitGroup、Once、Cond、Pool 等。

相比 channel，sync 更适合处理共享内存并发模型，尤其是在需要高性能或细粒度控制时。

互斥锁：sync.Mutex

最基础的同步工具是 Mutex（互斥锁），用于保证同一时间只有一个 goroutine 可以访问共享资源。

go 复制代码

package main

import (
	"fmt"
	"sync"
)

var (
	count int
	mu    sync.Mutex
)

func add() {
	mu.Lock()
	count++
	mu.Unlock()
}

func main() {

	for i := 0; i < 1000; i++ {
		go add()
	}

	// 简单等待（真实项目应使用 WaitGroup）
	fmt.Scanln()

	fmt.Println(count)
}

如果没有加锁，多个 goroutine 同时修改 count，会导致数据错误（竞态条件）。加锁后可以保证数据安全。

需要注意的是：

Lock() 和 Unlock() 必须成对出现
通常推荐使用 defer mu.Unlock() 防止遗漏

读写锁：sync.RWMutex

当读操作远多于写操作时，可以使用读写锁优化性能。

go 复制代码

var rw sync.RWMutex

// 读
rw.RLock()
value := count
rw.RUnlock()

// 写
rw.Lock()
count++
rw.Unlock()

特点：

多个读可以并发执行
写操作是独占的

适用于：

缓存系统配置读取高读低写场景

等待组：sync.WaitGroup

WaitGroup 用于等待一组 goroutine 执行完成，是并发编程中最常用的工具之一。

go 复制代码

package main

import (
	"fmt"
	"sync"
)

func worker(id int, wg *sync.WaitGroup) {
	defer wg.Done()
	fmt.Println("worker", id)
}

func main() {

	var wg sync.WaitGroup

	for i := 0; i < 5; i++ {
		wg.Add(1)
		go worker(i, &wg)
	}

	wg.Wait()

	fmt.Println("all done")
}

执行流程：

Add(n) 设置任务数量
每个 goroutine 完成后调用 Done()
Wait() 阻塞直到所有任务完成

这是 Go 中控制并发任务结束的标准方式。

只执行一次：sync.Once

Once 用于保证某段代码只执行一次，常用于初始化操作。

go 复制代码

var once sync.Once

func initConfig() {
	fmt.Println("初始化配置")
}

func main() {

	for i := 0; i < 3; i++ {
		go once.Do(initConfig)
	}

	fmt.Scanln()
}

无论调用多少次 Do()，函数只会执行一次。

适用于：

单例模式配置加载资源初始化

条件变量：sync.Cond

Cond 用于在 goroutine 之间进行条件通知，类似"等待-唤醒"机制。

go 复制代码

var mu sync.Mutex
cond := sync.NewCond(&mu)

ready := false

go func() {
	cond.L.Lock()
	for !ready {
		cond.Wait()
	}
	fmt.Println("开始执行")
	cond.L.Unlock()
}()

// 模拟准备完成
cond.L.Lock()
ready = true
cond.Signal()
cond.L.Unlock()

常见方法：

scss 复制代码

Wait()    等待条件
Signal()  唤醒一个
Broadcast() 唤醒所有

适用于：

生产者消费者模型任务调度系统

对象池：sync.Pool

sync.Pool 用于缓存临时对象，减少内存分配，提高性能。

go 复制代码

var pool = sync.Pool{
	New: func() interface{} {
		return make([]byte, 1024)
	},
}

func main() {

	buf := pool.Get().([]byte)

	// 使用 buf

	pool.Put(buf)
}

特点：

自动回收（受 GC 管理）
减少频繁分配内存

适用于：

高频创建销毁对象日志系统序列化处理

Map 并发安全：sync.Map

Go 原生 map 不是并发安全的，sync.Map 提供了并发安全的 map。

go 复制代码

var m sync.Map

m.Store("key", "value")

v, ok := m.Load("key")

fmt.Println(v, ok)

常用方法：

sql 复制代码

Store
Load
Delete
Range

适用于：

读多写少场景缓存系统

sync 与 channel 对比

Go 并发有两种主流方式：

channel sync

对比：

方式	特点
channel	通信优先
sync	共享内存控制

简单理解：

channel：通过通信共享数据
sync：通过共享内存同步数据

实际开发中，两者通常结合使用。

常见使用场景

在实际项目中，sync 广泛应用于：

并发计数器（Mutex）任务调度（WaitGroup）单例初始化（Once）缓存系统（RWMutex / sync.Map）高性能对象复用（Pool）

例如实现一个并发安全计数器：

go 复制代码

type Counter struct {
	mu sync.Mutex
	n  int
}

func (c *Counter) Add() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.n++
}

常见错误

忘记 Unlock：

go 复制代码

mu.Lock()
// 没有 Unlock

导致死锁。

WaitGroup 使用错误：

go 复制代码

wg.Add(1)
wg.Wait()
go func() {
	wg.Done()
}()

可能 panic。

复制 sync 对象：

go 复制代码

mu2 := mu // 错误

sync 类型不能复制。

使用建议

实际开发中推荐：

简单同步用 Mutex 读多写少用 RWMutex 等待任务用 WaitGroup 初始化用 Once 高性能缓存用 Pool 并发 map 用 sync.Map

同时注意：

尽量避免锁粒度过大避免死锁合理设计并发结构

总结

sync 是 Go 并发编程的核心工具库，它提供了一整套用于 协调 goroutine、保护共享数据、控制执行顺序 的机制。

核心组件包括：

Mutex / RWMutex：数据安全 WaitGroup：任务同步 Once：单次执行 Cond：条件通知 Pool：性能优化 sync.Map：并发 map

在高并发系统、Web 服务、任务调度器、缓存系统等场景中，sync 都是不可或缺的基础工具。熟练掌握 sync，可以让你的 Go 程序在并发安全和性能方面达到更高水平。