使用 sync.Mutex、sync.RWMutex、channel 封装或 atomic 操作实现 Golang 并发安全结构体，根据场景选择：读多写少用 RWMutex，简单变量用 atomic，强一致性用 channel，常规场景用 Mutex。
在 Golang 中实现并发安全的结构体操作，核心在于防止多个 goroutine 同时读写共享数据导致的数据竞争。结构体作为复合类型，通常包含多个字段，一旦被多个协程访问，就必须引入同步机制来保证一致性。下面介绍几种常见且实用的方法。
使用 sync.Mutex 保护结构体字段
最直接的方式是通过 sync.Mutex 来锁住对结构体的读写操作。适用于读写都较频繁但并发量不极端的场景。
定义一个结构体，并嵌入 sync.Mutex，每次访问字段前加锁，操作完成后解锁：
type SafeCounter struct {
mu sync.Mutex
value map[string]int
}
<p>func (c *SafeCounter) Inc(key string) {
c.mu.Lock()
defer c.mu.Unlock()
c.value[key]++
}</p><p>func (c *SafeCounter) Get(key string) int {
c.mu.Lock()
defer c.mu.Unlock()
return c.value[key]
}</p>注意：如果结构体字段较多或操作较复杂，仍需确保所有公共方法都正确加锁，避免遗漏。
立即学习“go语言免费学习笔记（深入）”；
使用 sync.RWMutex 提升读性能
当结构体以读操作为主、写操作较少时，使用 sync.RWMutex 可显著提升性能。它允许多个读操作并发进行，仅在写时独占锁。
type ReadOnlyFrequent struct {
mu sync.RWMutex
data map[string]interface{}
}
<p>func (r *ReadOnlyFrequent) Get(key string) interface{} {
r.mu.RLock()
defer r.mu.RUnlock()
return r.data[key]
}</p><p>func (r *ReadOnlyFrequent) Set(key string, value interface{}) {
r.mu.Lock()
defer r.mu.Unlock()
r.data[key] = value
}</p>读用 RLock()，写用 Lock()，这样多个 goroutine 可同时调用 Get 而不阻塞。
通过 channel 实现线程安全的操作封装
Golang 推崇“通过通信共享内存”，而不是“通过共享内存通信”。可以将结构体操作封装在专用 goroutine 中，外部通过 channel 发送指令。
这种方式适合需要严格顺序执行或复杂状态管理的场景：
type Command struct {
key string
value int
op string // "inc", "get"
resp chan int
}
<p>type Counter struct {
data map[string]int
cmd chan Command
}</p><p>func NewCounter() *Counter {
c := &Counter{
data: make(map[string]int),
cmd: make(chan Command),
}
go c.run()
return c
}</p><p>func (c *Counter) run() {
for cmd := range c.cmd {
switch cmd.op {
case "inc":
c.data[cmd.key]++
case "get":
cmd.resp <- c.data[cmd.key]
}
}
}</p><p>func (c *Counter) Inc(key string) {
c.cmd <- Command{key: key, op: "inc"}
}</p><p>func (c *Counter) Get(key string) int {
resp := make(chan int)
c.cmd <- Command{key: key, op: "get", resp: resp}
return <-resp
}</p>所有操作都在一个 goroutine 内完成，天然避免了并发问题，同时对外提供简单接口。
原子操作适用于简单字段
如果结构体只包含基本类型（如 int64、指针等），可考虑使用 sync/atomic 包进行原子操作。但它不能直接用于结构体整体，仅限特定字段。
例如计数器场景：
type AtomicCounter struct {
count int64
}
<p>func (a *AtomicCounter) Inc() {
atomic.AddInt64(&a.count, 1)
}</p><p>func (a *AtomicCounter) Load() int64 {
return atomic.LoadInt64(&a.count)
}</p>原子操作效率高，但限制多，不适合复杂结构体或组合操作。
基本上就这些常用方式。选择哪种取决于你的使用场景：简单共享变量用 atomic，读多写少用 RWMutex，强一致性要求可用 channel 封装。关键是避免竞态，同时兼顾性能和可维护性。
