理解Go中的syncCond：生产者-消费者场景中的Goroutine同步

package main

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

const buffersize = 5

type buffer struct {
    data []int
    mu   sync.mutex
    cond *sync.cond
}

func (b *buffer) produce(item int) {
    // producer logic to add item to the buffer
}

func (b *buffer) consume() int {
    // consumer logic to remove item from the buffer
    return 0
}

func main() {
    buffer := &buffer{data: make([]int, 0, buffersize)}
    buffer.cond = sync.newcond(&buffer.mu)
    var wg sync.waitgroup

    // start producer goroutines
    for i := 1; i <= 3; i++ {
        wg.add(1)
        go func(id int) {
            defer wg.done()
            for j := 0; j < 5; j++ { // each producer creates 5 items
                buffer.produce(id*10 + j) // produce unique items based on id and j
                time.sleep(100 * time.millisecond)
            }
        }(i)
    }

    // start consumer goroutines
    for i := 1; i <= 3; i++ {
        wg.add(1)
        go func(id int) {
            defer wg.done()
            for j := 0; j < 5; j++ { // each consumer consumes 5 items
                item := buffer.consume()
                fmt.printf("consumer %d consumed item %d\n", id, item)
                time.sleep(150 * time.millisecond)
            }
        }(i)
    }

    wg.wait()
    fmt.println("all producers and consumers finished.")
}

buffer.cond = sync.newcond(&buffer.mu)

func (b *buffer) produce(item int) {
    b.mu.lock()
    defer b.mu.unlock()

    // wait if the buffer is full
    for len(b.data) == buffersize {
        b.cond.wait() // release lock and wait until signaled
    }

    // add item to the buffer
    b.data = append(b.data, item)
    fmt.printf("produced item %d\n", item)

    // signal a consumer that an item is available
    b.cond.signal()
}

func (b *Buffer) consume() int {
    b.mu.Lock()
    defer b.mu.Unlock()

    // Wait if the buffer is empty
    for len(b.data) == 0 {
        b.cond.Wait() // Release lock and wait until signaled
    }

    // Remove item from the buffer
    item := b.data[0]
    b.data = b.data[1:]
    fmt.Printf("Consumed item %d\n", item)

    // Signal a producer that space is available
    b.cond.Signal()

    return item
}