go常见并发模式(2)：生产者模式

1. 方式1

// producer 生产者
func producer(c chan<- int) {
    defer close(c)

    for i := 0; i < 10; i++ {
        c <- i + 1
        time.Sleep(time.Millisecond * 100)
    }
}

// consumer 消费者
func consumer(c <-chan int) {
    for item := range c {
        fmt.Println(item)
    }
}

func main() {
    c := make(chan int)

    go producer(c)
    consumer(c)
}

2. 方式2

// producer 生产者
func producer(c chan<- int) {
    defer close(c)

    for i := 0; i < 10; i++ {
        c <- i + 1
        time.Sleep(time.Millisecond * 100)
    }
}

// consumer 消费者
func consumer(c <-chan int, o chan<- struct{}) {
    for item := range c {
        fmt.Println(item)
    }
    o <- struct{}{}
}

func main() {
    c := make(chan int)
    over := make(chan struct{}) // 开关

    go producer(c)
    go consumer(c, over)
    <-over
}

方式2将消费者和生产者都改为协程执行，然后通过一个开关来阻塞主程，当消费者执行完成后塞入一个空结构体，主程收到后结束阻塞

3. 方式3

// producer 生产者
func producer(c chan<- int) {
    defer close(c)

    for i := 0; i < 10; i++ {
        c <- i + 1
        time.Sleep(time.Millisecond * 100)
    }
}

// consumer 消费者
func consumer(c <-chan int) (result chan struct{}) {
    result = make(chan struct{})

    go func() {
        defer func() {
            result <- struct{}{}
        }()

        for item := range c {
            fmt.Println(item)
        }
    }()
    return
}

func main() {
    c := make(chan int)

    go producer(c)
    res := consumer(c)
    <-res
}

方式3将2的开关改写到消费者内部，更加通俗易懂