Go语言中并发更新结构体字段的正确姿势：避免值拷贝陷阱

// 简化的问题复现示例
type Server interface {
    GetId() int
}

type ServerInstance struct {
    Id int
}

func (s ServerInstance) GetId() int {
    return s.Id
}

// 模拟goroutine更新Id的方法，需要接收指针
func (s *ServerInstance) UpdateId(newId int) {
    s.Id = newId
}

// 这是一个会引发问题的工厂函数：它返回 ServerInstance 的值
func createProblematicServer(initialId int) Server {
    instance := ServerInstance{Id: initialId}
    // 启动goroutine更新这个instance的Id，但goroutine操作的是instance的地址
    go func(s *ServerInstance) {
        for i := 0; ; i++ {
            s.UpdateId(initialId + i + 100) // 实际更新了内存中的instance
            time.Sleep(100 * time.Millisecond)
        }
    }(&instance) // 将instance的地址传递给goroutine
    return instance // !!! 核心问题：这里返回的是 instance 的一个值拷贝
}

// 主程序中
// arr := []Server{}
// arr = append(arr, createProblematicServer(1)) // 切片中存储的是 instance 的一个副本
// ...
// for _, s := range arr {
//     print s.GetId() // 访问的是副本的Id，不会随原始instance的更新而变化
// }

package main

import (
    "fmt"
    "sync"
    "time"
)

// Server 接口定义
type Server interface {
    GetId() int
}

// ServerInstance 结构体实现 Server 接口
type ServerInstance struct {
    Id int
    mu sync.Mutex // 引入互斥锁以确保Id字段的并发安全更新
}

// GetId 方法：这里使用值接收者 (s ServerInstance) 仍然可行，
// 因为当接口持有指针时，Go会自动解引用以调用此方法。
func (s ServerInstance) GetId() int {
    // 在读取时也需要考虑并发安全，虽然本例主要关注可见性，
    // 但在实际生产中，共享数据的读写都需要保护。
    // s.mu.Lock() // 严格来说，如果GetId也需要保护，应该这样做
    // id := s.Id
    // s.mu.Unlock()
    // return id
    return s.Id
}

// UpdateId 方法：必须使用指针接收者 (s *ServerInstance) 才能修改原始结构体
func (s *ServerInstance) UpdateId(newId int) {
    s.mu.Lock() // 锁定，防止并发写入导致数据竞争
    s.Id = newId
    s.mu.Unlock() // 解锁
}

// createAndUpdateServerPointer 返回一个 *ServerInstance 的指针作为 Server 接口
func createAndUpdateServerPointer(initialId int) Server {
    instance := &ServerInstance{Id: initialId} // 创建一个结构体指针
    go func(s *ServerInstance) {                // Goroutine 操作这个指针
        for i := 0; ; i++ {
            s.UpdateId(initialId + i + 100)
            time.Sleep(100 * time.Millisecond)
        }
    }(instance) // 将指针传递给goroutine
    return instance // !!! 关键：这里返回的是一个指向 ServerInstance 的指针
}

func main() {
    fmt.Println("--- 场景一：存储结构体值 (问题复现) ---")
    var serversValue []Server
    // 这里调用 createProblematicServer，它返回 ServerInstance 的值
    // 为了演示，我们直接在main中模拟其行为
    inst1 := ServerInstance{Id: 1}
    go func(s *ServerInstance) {
        for i := 0; ; i++ {
            s.UpdateId(1 + i + 100)
            time.Sleep(100 * time.Millisecond)
        }
    }(&inst1)
    serversValue = append(serversValue, inst1) // append的是inst1的值拷贝

    inst2 := ServerInstance{Id: 2}
    go func(s *ServerInstance) {
        for i := 0; ; i++ {
            s.UpdateId(2 + i + 100)
            time.Sleep(100 * time.Millisecond)
        }
    }(&inst2)
    serversValue = append(serversValue, inst2) // append的是inst2的值拷贝

    fmt.Println("值拷贝场景: 初始状态")
    for _, s := range serversValue {
        fmt.Printf("%d ", s.GetId())
    }
    fmt.Println()

    fmt.Println("值拷贝场景: 观察更新（不会反映）")
    go func() {
        for i := 0; i < 5; i++ { // 观察5次
            fmt.Print("值拷贝场景: ")
            for _, s := range serversValue {
                fmt.Printf("%d ", s.GetId()) // s 是接口值的副本，它持有 ServerInstance 值的副本
            }
            fmt.Println()
            time.Sleep(500 * time.Millisecond)
        }
    }()

    time.Sleep(3 * time.Second) // 留出时间观察值拷贝场景

    fmt.Println("\n--- 场景二：存储结构体指针 (解决方案) ---")
    var serversPointer []Server
    // 使用修正后的工厂函数，它返回 *ServerInstance 的指针
    serversPointer = append(serversPointer, createAndUpdateServerPointer(10))
    serversPointer = append(serversPointer, createAndUpdateServerPointer(20))

    fmt.Println("指针存储场景: 初始状态")
    for _, s := range serversPointer {
        fmt.Printf("%d ", s.GetId())
    }
    fmt.Println()

    fmt.Println("指针存储场景: 观察更新（会反映）")
    go func() {
        for i := 0; i < 5; i++ { // 观察5次
            fmt.Print("指针存储场景: ")
            for _, s := range serversPointer {
                fmt.Printf("%d ", s.GetId()) // s 是接口值的副本，但它持有 *ServerInstance 的指针
            }
            fmt.Println()
            time.Sleep(500 * time.Millisecond)
        }
    }()

    time.Sleep(3 * time.Second) // 留出时间观察指针存储场景
}