美文网首页
go常见并发模式(2):生产者模式

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

作者: 快感炮神 | 来源:发表于2020-09-19 14:29 被阅读0次
    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)
    }
    
    1. 方式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将消费者和生产者都改为协程执行,然后通过一个开关来阻塞主程,当消费者执行完成后塞入一个空结构体,主程收到后结束阻塞

    1. 方式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的开关改写到消费者内部,更加通俗易懂

    相关文章

      网友评论

          本文标题:go常见并发模式(2):生产者模式

          本文链接:https://www.haomeiwen.com/subject/tfveyktx.html