Go 并发修改结构体切片：从切片语义到并发安全机制

type Window struct {
    Height int64 `json:"Height"`
    Width  int64 `json:"Width"`
}
type Room struct {
    Windows []Window `json:"Windows"`
}

func addWindow(windows []Window) {
    window := Window{1, 1}
    fmt.Printf("Adding %v to %v\n", window, windows)
    windows = append(windows, window) // 这里的修改可能不会反映到调用者
}

func main() {
    // ... 初始化 room ...
    // go func() {
    //     defer wg.Done()
    //     addWindow(room.Windows) // 传入的是 room.Windows 的副本
    // }()
    // ...
}

func addWindowAndReturn(windows []Window) []Window {
    window := Window{1, 1}
    // 模拟耗时计算
    return append(windows, window)
}

// 调用示例：
// room.Windows = addWindowAndReturn(room.Windows)

type Room struct {
    Windows []Window `json:"Windows"`
}

func addWindowToRoom(room *Room) {
    window := Window{1, 1}
    // 模拟耗时计算
    room.Windows = append(room.Windows, window) // 直接修改指针指向的 Room 实例的 Windows 字段
}

// 调用示例：
// addWindowToRoom(&room)

// createWindow 函数负责生成一个 Window 并发送到 Channel
func createWindow(windowsChan chan<- Window) {
    // 模拟耗时计算
    window := Window{1, 1}
    windowsChan <- window // 将生成的 Window 发送到 Channel
}

// 在主 Goroutine 或协调 Goroutine 中：
func main() {
    // ... 初始化 room ...

    numToAdd := 10 // 假设要添加 10 个窗口
    windowsChan := make(chan Window, numToAdd) // 创建一个带缓冲的 Channel

    var wg sync.WaitGroup
    // 启动 N 个 Goroutine 并发生成 Window
    for i := 0; i < numToAdd; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            createWindow(windowsChan)
        }()
    }
    wg.Wait() // 等待所有窗口生成 Goroutine 完成
    close(windowsChan) // 关闭 Channel，表示不再有新的 Window 产生

    // 主 Goroutine 顺序地从 Channel 接收 Window 并添加到 room.Windows
    for newWindow := range windowsChan {
        room.Windows = append(room.Windows, newWindow)
    }

    // ... 验证结果 ...
}

import "sync"

type Room struct {
    m       sync.Mutex // 内嵌互斥锁
    Windows []Window   `json:"Windows"`
}

// AddWindow 方法负责安全地向 Room 添加 Window
func (r *Room) AddWindow(window Window) {
    r.m.Lock()         // 获取锁
    defer r.m.Unlock() // 确保在函数返回前释放锁，即使发生 panic
    r.Windows = append(r.Windows, window)
}

// 调用示例：
// var room Room
// // ... 初始化 room ...
// var wg sync.WaitGroup
// for i := 0; i < 10; i++ {
//     wg.Add(1)
//     go func() {
//         defer wg.Done()
//         r.AddWindow(Window{1, 1}) // 通过方法调用，内部自动加锁
//     }()
// }
// wg.Wait()

import "sync"

var globalAddWindowMutex sync.Mutex // 全局互斥锁

func addWindowGlobally(room *Room) {
    globalAddWindowMutex.Lock()         // 获取全局锁
    defer globalAddWindowMutex.Unlock() // 确保释放锁
    room.Windows = append(room.Windows, Window{1, 1})
}

// 调用示例：
// var room Room
// // ... 初始化 room ...
// var wg sync.WaitGroup
// for i := 0; i < 10; i++ {
//     wg.Add(1)
//     go func() {
//         defer wg.Done()
//         addWindowGlobally(&room) // 即使是不同的 room 实例，也会串行化
//     }()
// }
// wg.Wait()