在Golang的并发编程场景中，多个goroutine经常需要访问同一份数据资源，指针可以直接指向共享资源的内存地址，让不同协程能够操作同一份数据，是实现共享资源管理的核心手段。不过如果直接使用指针操作共享资源，很容易引发数据竞争问题，需要结合对应的同步机制才能安全使用。
指针管理共享资源的基础原理
指针的本质是存储变量的内存地址，当我们把一个变量的指针传递给多个goroutine时，这些goroutine都可以通过这个指针访问到同一块内存区域的数据，也就实现了共享资源的访问。比如我们定义一个结构体类型的共享资源，把它的指针传递给不同的协程，协程就可以通过指针修改结构体的字段值。
下面是一段基础的使用指针传递共享资源的示例代码：
package main
import (
"fmt"
)
// 定义共享资源结构体
type SharedData struct {
Value int
}
func main() {
// 初始化共享资源
data := &SharedData{Value: 0}
// 打印初始值
fmt.Println("初始值:", data.Value)
// 通过指针修改值
modifyData(data)
fmt.Println("修改后的值:", data.Value)
}
// 接收指针参数，修改共享资源
func modifyData(d *SharedData) {
d.Value = 100
}
无同步机制下的指针共享资源问题
如果多个goroutine同时通过一个指针操作共享资源，且没有同步机制保护，就会出现数据竞争，导致最终的结果不符合预期。比如我们启动两个goroutine同时对同一个指针指向的共享资源做累加操作，正常情况下两次累加后值应该是200，但实际运行结果可能小于200。
以下是存在数据竞争的问题代码示例：
package main
import (
"fmt"
"time"
)
type SharedCounter struct {
Count int
}
func main() {
counter := &SharedCounter{Count: 0}
// 启动第一个goroutine累加100次
go func() {
for i := 0; i < 100; i++ {
counter.Count++
}
}()
// 启动第二个goroutine累加100次
go func() {
for i := 0; i < 100; i++ {
counter.Count++
}
}()
// 等待goroutine执行完成
time.Sleep(time.Second)
fmt.Println("最终计数:", counter.Count)
}
多次运行这段代码，你会发现最终输出的计数结果可能是100到200之间的任意值，这就是因为没有同步机制保护，两个goroutine同时修改counter.Count时出现了数据覆盖的问题。
搭配同步机制的安全管理方案
使用互斥锁保护指针共享资源
互斥锁是Golang中最常用的同步工具，我们可以在共享资源结构体中嵌入sync.Mutex，每次操作共享资源前加锁，操作完成后解锁，这样就能保证同一时间只有一个goroutine可以操作共享资源，避免数据竞争。
下面是使用互斥锁优化后的安全计数示例：
package main
import (
"fmt"
"sync"
"time"
)
// 共享资源结构体，嵌入互斥锁
type SafeCounter struct {
mu sync.Mutex
Count int
}
func main() {
counter := &SafeCounter{Count: 0}
// 启动第一个goroutine累加100次
go func() {
for i := 0; i < 100; i++ {
counter.mu.Lock()
counter.Count++
counter.mu.Unlock()
}
}()
// 启动第二个goroutine累加100次
go func() {
for i := 0; i < 100; i++ {
counter.mu.Lock()
counter.Count++
counter.mu.Unlock()
}
}()
// 等待goroutine执行完成
time.Sleep(time.Second)
fmt.Println("最终安全计数:", counter.Count)
}
运行这段代码后，最终输出的计数结果永远是200，因为互斥锁保证了每次只有一個goroutine可以执行累加操作。
使用读写锁优化读多写少场景
如果共享资源的读操作远多于写操作，使用互斥锁会导致读操作之间也被阻塞，效率较低。这时候可以使用sync.RWMutex读写锁，读操作加读锁，写操作加写锁，多个读操作可以同时进行，只有写操作的时候才会阻塞其他读写操作。
读写锁的使用示例如下：
package main
import (
"fmt"
"sync"
"time"
)
type SafeData struct {
mu sync.RWMutex
Data map[string]int
}
func main() {
sd := &SafeData{
Data: make(map[string]int),
}
// 写操作协程
go func() {
for i := 0; i < 5; i++ {
sd.mu.Lock()
sd.Data[fmt.Sprintf("key_%d", i)] = i
sd.mu.Unlock()
time.Sleep(100 * time.Millisecond)
}
}()
// 多个读操作协程
for i := 0; i < 3; i++ {
go func(id int) {
for {
sd.mu.RLock()
fmt.Printf("读协程%d读取数据: %vn", id, sd.Data)
sd.mu.RUnlock()
time.Sleep(50 * time.Millisecond)
}
}(i)
}
time.Sleep(time.Second * 2)
}
指针管理共享资源的注意事项
- 不要将局部变量的指针返回到函数外部，局部变量在函数执行结束后内存会被回收，外部使用这个指针会导致未定义行为。
- 如果共享资源不需要被修改，可以使用常量指针或者传递值的副本，避免不必要的指针操作带来的风险。
- 使用指针管理共享资源时，一定要明确资源的生命周期，避免指针悬挂导致的资源访问错误。
- 除了锁机制之外，也可以结合
channel来传递指针，通过channel的通信机制来协调共享资源的访问，这也是Golang提倡的并发编程方式。
以下是使用channel传递指针管理共享资源的简单示例：
package main
import (
"fmt"
)
type TaskData struct {
Result int
}
func main() {
dataChan := make(chan *TaskData, 1)
// 初始化共享资源指针放入channel
dataChan <- &TaskData{Result: 0}
// 处理协程从channel取指针操作资源
go func() {
d := <-dataChan
d.Result = 50
dataChan <- d
}()
// 主协程取结果
finalData := <-dataChan
fmt.Println("channel传递指针的结果:", finalData.Result)
}