如何在Golang中使用指针进行并发安全访问_结合sync包示例_技术教程

Go中指针本身不提供并发安全，真正保障安全的是sync包中的同步机制；指针仅用于共享数据结构地址，需配合Mutex、RWMutex或Atomic等正确同步访问。

Go 中的指针本身不提供并发安全，真正保障并发安全的是同步机制（如 sync.Mutex、sync.RWMutex、sync.Atomic 等），而指针常用于共享数据结构的地址传递——这是并发访问的前提。关键不在于“用指针做并发安全”，而在于“如何通过指针共享数据，并配合 sync 包正确同步访问”。

用指针共享结构体 + Mutex 保护字段访问

多个 goroutine 通常通过指针共享同一结构体实例。若结构体含可变字段，需用互斥锁保护读写。

示例：计数器结构体

type Counter struct {
    mu    sync.Mutex
    value int
}

func (c *Counter) Inc() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

func (c *Counter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}

注意：方法接收者为 *Counter（指针），才能修改原结构体；mu 必须是值类型（非指针），否则复制结构体会导致锁失效。

避免指针误共享：不要直接共享未加锁的原始变量指针

以下写法是危险的：

var x int
go func() { *(&x)++ }() // 错误：无同步，竞态
go func() { fmt.Println(*(&x)) }()

即使用了指针，没有同步原语，仍会触发竞态检测（go run -race 可捕获）。正确做法是封装+同步，或改用原子操作。

原始类型（int32/int64/uint32/bool/uintptr）优先考虑 sync/atomic
例如：var total int64; atomic.AddInt64(&total, 1) —— 这里 &total 是取地址，但原子操作内部已保证线程安全

读多写少场景：用 RWMutex + 指针提升读性能

当结构体读操作远多于写操作时，用 sync.RWMutex 允许多个 goroutine 同时读，仅写时独占。

type Config struct {
    mu     sync.RWMutex
    data   map[string]string
}

func (c *Config) Get(key string) string {
    c.mu.RLock()
    defer c.mu.RUnlock()
    return c.data[key]
}

func (c *Config) Set(key, val string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.data[key] = val
}

注意：map 本身不是并发安全的，必须由外部锁保护；RWMutex 的读锁不能替代互斥锁对 map 写操作的保护。

指针与 channel 协作：避免共享内存，用通信代替

Go 推崇“不要通过共享内存来通信，而应通过通信来共享内存”。这时指针常用于传递消息内容，而非长期共享。

type Task struct {
    ID    int
    Data  []byte
}

ch := make(chan *Task, 10)
go func() {
    for t := range ch {
        // 处理 *t，无需锁 —— 因为所有权已移交至此 goroutine
        process(t)
    }
}()

只要确保同一时刻只有一个 goroutine 持有该指针（即不把同一指针发给多个 goroutine 并发读写），就天然避免了竞态。

若需广播或复用，应深拷贝或使用不可变数据结构。

不复杂但容易忽略：指针只是共享的手段，sync 才是安全的根基；用错锁粒度、漏锁、复制带锁结构体、或在锁外暴露可变字段，都会导致并发问题。