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) // 如果切片容量不足，会创建新的底层数组
}

// ... main 函数中调用
// go func() {
//     defer wg.Done()
//     addWindow(room.Windows) // 传递的是 room.Windows 的副本
// }()

func addWindowAndReturn(windows []Window) []Window {
    window := Window{1, 1}
    // 假设这里有一些耗时计算
    fmt.Printf("Adding %v to %v\n", window, windows)
    return append(windows, window)
}

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

func addWindowToRoom(room *Room) {
    window := Window{1, 1}
    // 假设这里有一些耗时计算
    fmt.Printf("Adding %v to %v\n", window, room.Windows)
    room.Windows = append(room.Windows, window)
}

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

func createWindowProducer(windowsChan chan<- Window) {
    // 假设这里有一些耗时计算来创建 Window
    window := Window{1, 1}
    windowsChan <- window // 将创建的 Window 发送到通道
}

func main() {
    // ... 解码 JSON 到 room ...

    numProducers := 10
    windowsChan := make(chan Window, numProducers) // 带缓冲通道，防止阻塞
    var wg sync.WaitGroup

    // 启动 N 个协程并发生产 Window
    for i := 0; i < numProducers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            createWindowProducer(windowsChan)
        }()
    }

    wg.Wait()      // 等待所有生产者完成
    close(windowsChan) // 关闭通道，表示不再有数据写入

    // 主协程串行地从通道接收并添加到 room.Windows
    for window := range windowsChan {
        room.Windows = append(room.Windows, window)
    }

    // ... 序列化 room 并打印 ...
}

import "sync"

type Room struct {
    mu      sync.Mutex // 保护 Windows 字段的互斥锁
    Windows []Window   `json:"Windows"`
}

// AddWindow 方法安全地向 Room 添加 Window
func (r *Room) AddWindow(window Window) {
    r.mu.Lock()         // 获取锁
    defer r.mu.Unlock() // 确保函数退出时释放锁
    r.Windows = append(r.Windows, window)
}

func main() {
    // ... 解码 JSON 到 room ...

    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            // 在协程中调用 Room 的安全方法
            r.AddWindow(Window{1, 1}) // 假设这里是具体的 Window 对象
        }()
    }
    wg.Wait()

    // ... 序列化 room 并打印 ...
}

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

func addWindowSafely(room *Room, window Window) {
    addWindowGlobalMutex.Lock()         // 获取全局锁
    defer addWindowGlobalMutex.Unlock() // 释放全局锁
    room.Windows = append(room.Windows, window)
}

func main() {
    // ... 解码 JSON 到 room ...

    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            addWindowSafely(&room, Window{1, 1})
        }()
    }
    wg.Wait()

    // ... 序列化 room 并打印 ...
}