Go中并发安全通过mutex、RWMutex、atomic和channel实现：互斥用Mutex，读多写少选RWMutex，原子操作用atomic，状态管理推荐channel，避免数据竞争并兼顾性能。

在Go语言中，并发编程非常常见，通过goroutine和channel可以轻松实现并发任务。但多个goroutine同时访问共享变量时，容易引发数据竞争（data race），导致程序行为不可预测。因此，正确处理并发安全的共享变量至关重要。

使用sync.Mutex保护共享变量

最常用的保护共享变量的方式是使用sync.Mutex。Mutex提供互斥锁机制，确保同一时间只有一个goroutine能访问临界区。

例如，多个goroutine同时对一个计数器进行递增操作：

示例代码：
var counter int
var mu sync.Mutex

func increment() {
  mu.Lock()
  counter++
  mu.Unlock()
}

每次修改counter前都调用Lock()，操作完成后立即Unlock()。这种方式简单有效，适用于大多数场景。

立即学习“go语言免费学习笔记（深入）”；

使用sync.RWMutex优化读多写少场景

当共享变量被频繁读取、较少写入时，使用sync.RWMutex更高效。它允许多个读操作并发执行，只在写操作时独占访问。

示例：
var config map[string]string
var rwMu sync.RWMutex

func readConfig(key string) string {<br>
  rwMu.RLock()<br>
  value := config[key]<br>
  rwMu.RUnlock()<br>
  return value<br>
}<br><br>

func updateConfig(key, value string) {<br>
  rwMu.Lock()<br>
  config[key] = value<br>
  rwMu.Unlock()<br>
}

读操作使用RLock，提升并发性能；写操作仍需Lock保证独占性。

Golang Uber Dig

使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等

下载

使用atomic包进行无锁原子操作

对于简单的整型变量操作（如加减、比较并交换），sync/atomic包提供了无锁的原子操作，性能更高且避免死锁风险。

示例：原子递增int64计数器
var atomicCounter int64

func incAtomic() {<br>
  atomic.AddInt64(&atomicCounter, 1)<br>
}

atomic还支持Load、Store、CompareAndSwap等操作，适合标志位、计数器等轻量级场景。

通过Channel实现变量共享

Go提倡“通过通信共享内存，而不是通过共享内存通信”。使用channel管理共享状态，可避免显式加锁。

例如，用一个专门的goroutine管理配置更新：

type configOp struct {
  key string
  value string
  resp chan string
}

var ops = make(chan configOp)<br><br>

func configManager() {<br>
  config := make(map[string]string)<br>
  for op := range ops {<br>
    config[op.key] = op.value<br>
    op.resp <- "ok"<br>
  }<br>
}<br><br>

func setConfig(k, v string) {<br>
  resp := make(chan string)<br>
  ops <- configOp{k, v, resp}<br>
  <-resp // 等待完成<br>
}

所有修改都通过channel发送给管理goroutine，自然保证了串行化和安全性。

基本上就这些。选择哪种方式取决于具体场景：简单互斥用Mutex，读多写少考虑RWMutex，计数器优先atomic，复杂状态管理推荐channel。关键是避免数据竞争，同时兼顾性能和可维护性。