Question

我正在学习go中的并发及其工作原理。

我要做什么？

遍历数据切片
为所需/所需数据创建结构
为该结构创建频道
使用go rutine调用worker func，并将该通道传递给该rutine
使用渠道中的数据进行一些处理
将处理后的输出设置回通道
等待主线程获取我们启动的所有通道的输出

我尝试过的代码

        package main

    import (
        "fmt"
        "github.com/pkg/errors"
        "time"
    )

    type subject struct {
        Name string
        Class string
        StartDate time.Time
        EndDate time.Time
    }

    type workerData struct {
        Subject string
        Class string
        Result string
        Error error
    }

    func main () {

        // Creating test data
        var subjects []subject
        st,_ := time.Parse("01/02/2016","01/01/2015")
        et,_ := time.Parse("01/02/2016","01/01/2016")
        s1 := subject{Name:"Math", Class:"3", StartDate:st,EndDate:et }
        s2 := subject{Name:"Geo", Class:"3", StartDate:st,EndDate:et }
        s3 := subject{Name:"Bio", Class:"3", StartDate:st,EndDate:et }
        s4 := subject{Name:"Phy", Class:"3", StartDate:st,EndDate:et }
        s5 := subject{Name:"Art", Class:"3", StartDate:st,EndDate:et }
        subjects = append(subjects, s1)
        subjects = append(subjects, s2)
        subjects = append(subjects, s3)
        subjects = append(subjects, s4)
        subjects = append(subjects, s5)
        c := make(chan workerData) // I am sure this is not how I should be creating channel

        for i := 0 ; i< len(subjects) ; i++ {
            go worker(c)
        }

        for _, v := range subjects {
            // Setting required data in channel
            data := workerData{Subject:v.Name, Class:v.Class}

            // set the data and start the routine
            c <- data // I think this will update data for all the routines ? SO how should create separate channel for each routine

        }

        // I want to wait till all the routines set the data in channel and return the data from workers.
        for {
            select {
                case data := <- c :
                    fmt.Println(data)
            }
        }
    }

    func worker (c chan workerData) {
        data := <- c
        // This can be any processing
        time.Sleep(100 * time.Millisecond)
        if data.Subject != "Math" {
            data.Result = "Pass"
        } else {
            data.Error = errors.New("Subject not found")
        }
        fmt.Println(data.Subject)
        // returning processed data and error to channel
        c <- data
        // Rightfully this closes channel and here after I get error send on Closed channel.
        close(c)
    }

Playgorund链接-https://play.golang.org/p/hs1-B1UR98r

我正在面对

我不确定如何为每个数据项创建不同的通道。我目前正在执行的方式将更新所有例程的通道数据。我想知道是否有办法为循环中的每个数据项创建差异通道，并将其传递给go rutine。然后在主程序中等待，以从所有通道的程序中获取结果。

任何指针/帮助都很好吗？如果有任何疑问，请随时发表评论。

Answer 1

“ //我想这会更新所有例程的数据吗？”

（为了简化）通道不是存储数据的数据结构。

它是通过不同 goroutines 发送和接收数据的结构。

这样，请注意您的辅助函数正在每个goroutine实例中的同一通道上进行发送和接收。如果您只有一个这样的工作程序实例，则会死锁（https://golang.org/doc/articles/race_detector.html）。

在您发布的代码版本中，对于初学者而言，这似乎可行，因为您有很多工作人员互相交换作品。但是正确的程序是错误的。

结果，如果工作人员无法读写同一通道，则它必须使用特定的可写通道才能将其结果发送到其他例程。

//我想等到所有例程在通道中设置数据并从工作人员那里返回数据。

这是同步机制的一部分，该机制可确保推杆在其所有工人完成工作之前一直等待，直到继续操作为止。（此博客文章讨论了https://medium.com/golangspec/synchronized-goroutines-part-i-4fbcdd64a4ec）

//正确地，它关闭了频道，在我收到错误信息后继续发送封闭频道。

请确保您有n个并行执行的工作程序例程。该工作人员中第一个到达其功能末端的操作将关闭该通道，从而使其无法被其他工作人员使用，并错误地指示其终止于主要人员。

通常，在编写器端使用close语句表示没有更多数据进入通道。表示已结束。读者消耗该信号以退出其通道的读取等待操作。

作为一个例子，让我们回顾一下这个循环

    for {
        select {
            case data := <- c :
                fmt.Println(data)
        }
    }

这很糟糕，真的很糟糕。

这是一个没有退出语句的无限循环
该选择是多余的，并且不包含exit语句，请记住，对通道的读取是一项阻塞操作。
这是对语言提供的标准模式的错误重写，通道上的范围循环

通道的范围循环非常简单

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

此模式有一个很大的优势，它会自动检测到关闭的通道退出循环！让您仅循环处理相关数据。它也更简洁。

此外，您的工作人员很尴尬，因为它在退出之前只能读写一个元素。生成go例程很便宜，但不是免费的。您应该始终评估异步处理的成本与其实际工作量之间的权衡。

总体而言，您的代码应更接近此处演示的内容 https://gobyexample.com/worker-pools

如何循环创建通道？

1 个答案: