其实，

一、为什么需要并发安全？

当你在业务程序中使用多 goroutine 读写共享状态时如果没有同步手段，往往会出现数据错乱、日志异常甚至服务崩溃。说起来，常见痛点包括这方面。

• 偶尔出现的“数据为零值”或“结果比预期小”的现象，难以复现。
• 在高峰期观察到 CPU 占用飙升，却不知是因为锁竞争还是无锁操作失误。
• 团队成员对何时加锁、如何选型感到困惑，导致代码难以维护。

// 资源竞态示例
var counter int
func increment {
defer wg.Done
for i := 0;i <1000; i++ {
        counter++ // 非原子操作时读→改→写，这三步之间可被中断
    }
}
func main {
    var wg sync.WaitGroup // 对于 sync.WaitGroup 下文会讲到
    for i := 0; i <10; i++ {
        wg.Add
        go increment // 启动10个协程循环写
    }
    wg.Wait // 等待协程执行完成
    fmt.Println // 期望 10000 ，实际往往小于10000
}

用 go run -race 可自动检测竞态，也能帮你快速定位问题。

二、四大并发安全机制

graph TD
A --> B
A --> C
A --> D
A --> E
B --> B1
B --> B2
C --> C1
C --> C2
D --> D1
D --> D2
E --> E1
E --> E2

三、方式一：sync.Mutex

最常用、最直观的方式：

type Counter struct {
mu sync.Mutex // 原子锁
counter int
}
func Inc { //让counter+=
c.mu.Lock
defer c.mu.Unlock // defer 保证解锁
c.counter++
}
func Value int { //获取counter的值
c.mu.Lock
defer c.mu.Unlock
return c.counter
}

RWMutex：读多写少场景

type Cache struct {
mu sync.RWMutex
data mapstring
}
func Get string { //获取key的value
c.mu.RLock // 多个 reader 可并发
defer c.mu.RUnlock
return c.data
}
func Set { //设置key的value
c.mu.Lock // writer 独占
defer c.mu.Unlock
c.data = val
}

顺带一提官方提供了并发安全的 map：sync.Map适合读多写少且 key 稳定的场景，可以根据使用场景考虑。

四、方式二：sync/atomic

无锁、高性能，仅适用于简单数值操作：

var counter int64
func increment {
atomic.AddInt64 // 原子加
}
// 支持的操作
atomic.AddInt64 // 原子加
atomic.LoadInt64 // 原子读
atomic.StoreInt64 // 原子写
atomic.SwapInt64 // 原子交换。返回旧值
atomic.CompareAndSwapInt64 // CAS

CAS 示例：

var flag int32
if atomic.CompareAndSwapInt32 {
defer atomic.StoreInt32
// 临界区
}

五、方式三：Channel 通信同步

Go 官方哲学 —— 「通过通信来共享内存」：

// 用 channel 串行化所有写操作，使其顺序执行
updates := make
var counter int // 唯一能修改 counter 的 goroutine
go func {
for inc := range updates {
counter += inc
}
}
var wg sync.WaitGroup
for i := 0;i <10_000_000; i++ {  
    wg.Add
    go func {
        defer wg.Done
        updates <-1   // 发送即同步   
    }
}
wg.Wait
close   // 等待处理完  
 

还有更优雅的方式：状态管理器模式：

type command struct {
op string
resp chan int}
func counterManager {
counter := 0
for cmd := range cmdCh {
switch cmd.op {
case “inc”:
counter++
case “get”:
cmd.resp <- counter      
        }    
    }  
}  
// 主程序里启动一个 goroutine 并通过 cmdCh 发指令即可。  
 

六、方式四：sync.Once 等同步原语

sync.Once：单例安全初始化

var (
instance *Config
once sync.Once)
func GetConfig *Config {
once.Do{ /* 即使有多个 goroutine 并发调用 Do。也只有一个会真正执行，而其他 goroutine 会阻塞等待执行完成。*/
instance = loadConfig
})
return instance
}

sync.WaitGroup：等待一组 goroutine 完成

var wg sync.WaitGroup
for i:=0;i<5;i++{
    wg.Add
    go func{
        defer wg.Done
        doWork
    }
}
wg.Wait   /* 等待全部完成 */
 

七、对比与选型

以下图表帮助快速判断使用哪种同步工具更合适；但请注意不同项目对性能和易维护性的侧主要不同。所以这只是一个起点，而不是绝对规则。

\