答案：减少锁竞争需减小锁粒度、用读写锁优化读多写少场景、以原子操作替代互斥锁、避免共享数据。1. 分片锁降低争抢；2. RWMutex提升并发读性能；3. atomic实现无锁计数；4. copy-on-write或atomic.Value避免共享，结合业务设计可显著提升并发效率。
在高并发场景下，Golang 中的锁竞争会显著影响程序性能。即使使用了 goroutine 和 channel，不当的共享资源访问仍会导致大量线程阻塞在锁上。减少锁竞争的核心思路是：降低锁的持有时间、缩小锁的粒度、避免不必要的同步。以下是几种实用的优化策略。
1. 减小锁的粒度
将一个大锁拆分为多个小锁，可以有效降低多个 goroutine 同时争抢同一把锁的概率。
示例：比如有一个全局计数器 map，如果所有 key 共用一把互斥锁，写入频繁时会形成瓶颈。可以改为每个 key 或一组 key 使用独立的锁。
type ShardedCounter struct {
counters [16]map[string]int
locks [16]*sync.Mutex
}
func (sc *ShardedCounter) Inc(key string) {
shard := hash(key) % 16
sc.locks[shard].Lock()
sc.counters[shard][key]++
sc.locks[shard].Unlock()
}
通过分片（sharding），将锁的竞争分散到多个锁上，整体并发能力提升明显。
立即学习“go语言免费学习笔记（深入）”；
2. 使用读写锁（sync.RWMutex）
当资源以读为主、写为少时，使用 *sync.RWMutex* 能显著提升性能。多个读操作可以并发进行，只有写操作需要独占锁。
var mu sync.RWMutex
var cache = make(map[string]string)
func Get(key string) string {
mu.RLock()
defer mu.RUnlock()
return cache[key]
}
func Set(key, value string) {
mu.Lock()
defer mu.Unlock()
cache[key] = value
}
相比普通互斥锁，读写锁在高读低写场景下能减少大量等待。
3. 利用原子操作替代锁
对于简单的数据类型（如 int32、int64、指针），可以使用 *sync/atomic* 包进行无锁编程。
使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等
示例：统计请求数量时，用 atomic.AddInt64 比加锁更新 int64 变量更高效。
var counter int64
func inc() {
atomic.AddInt64(&counter, 1)
}
func get() int64 {
return atomic.LoadInt64(&counter)
}
原子操作由底层 CPU 指令支持，开销远小于 mutex，适合计数器、状态标志等场景。
4. 避免共享，使用局部变量或 copy-on-write
最彻底的减少锁竞争的方法是：不让多个 goroutine 共享数据。
可以通过以下方式实现：
- 为每个 goroutine 分配独立的数据副本
- 使用 copy-on-write 技术，在修改时复制数据，读取时不加锁
- 结合 channel 传递所有权，避免多协程同时访问
示例：配置热更新可采用 atomic.Value 存储不可变配置对象，更新时替换整个实例，读取时不加锁。
var config atomic.Value // stores *Config
func Load() *Config {
return config.Load().(*Config)
}
func Update(newCfg *Config) {
config.Store(newCfg)
}
只要配置对象本身不可变，这种模式就能实现无锁读取。
基本上就这些。合理选择锁策略，结合业务特点设计数据结构，才能真正发挥 Go 并发的优势。不复杂但容易忽略。
