Go 如何在循环中创建通道？

我正在学习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)
    }

主程序包
进口(
“fmt”
“github.com/pkg/errors”
“时间”
)
类型主题结构{
名称字符串
类字符串
开始时间，时间
结束日期时间
}
类型workerData结构{
主题字符串
类字符串
结果字符串
误差
}
func main（）{
//创建测试数据
var科目[]科目
st，:=时间解析（“2016年2月1日”、“2015年1月1日”）
et，:=time.Parse（“01/02/2016”、“01/01/2016”）
s1:=科目{名称：“数学”，班级：“3”，起始日期：st，结束日期：et}
s2:=受试者{姓名：“地理”，类别：“3”，起始日期：st，结束日期：et}
s3:=受试者{Name:“Bio”，Class:“3”，起始日期：st，结束日期：et}
s4:=受试者{姓名：“物理”，类别：“3”，起始日期：st，结束日期：et}
s5:=受试者{姓名：“艺术”，类别：“3”，起始日期：st，结束日期：et}
主题=附加（主题，s1）
主题=附加（主题，s2）
主题=附加（主题，s3）
主题=附加（主题，s4）
主题=附加（主题，s5）
c:=make（chan workerData）//我确信这不是我应该创建频道的方式
对于i:=0；i
通道（简化）不是存储数据的数据结构

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

因此，请注意，您的辅助函数在每个goroutine实例内的同一通道上执行发送和接收。如果您只有一个这样的辅助函数实例，这将导致死锁

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

因此，如果工作进程不能读写同一个通道，那么它必须使用一个特定的可写通道来将其结果发送给其他一些例程

//我想等到所有的例程在通道和
从工作人员返回数据

这是同步机制的一部分，需要确保推送程序等待所有工作人员完成工作后才能继续

//正确地说，这将关闭通道，在我收到错误发送后，在这里
封闭通道

请注意，您有n个并行执行的工作线程例程。此工作线程中第一个到达其函数末尾的将关闭通道，使其对其他工作线程不可写入，并向main发送错误的结束信号

通常情况下，在写入端使用close语句表示通道中没有更多数据。表示通道已结束。读卡器使用此信号退出通道的读取等待操作

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

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

这种模式有一个很大的优点，它自动检测一个闭合通道以退出循环！让您只循环处理相关数据。它也更加简洁

另外，你的员工是一个笨拙的人，因为他在辞职前只读写一个元素。
生成go例程很便宜，但不是免费的。您应该始终评估异步处理的成本与其实际工作负载之间的权衡

总的来说，您的代码应该更接近这里演示的内容

“//我认为这将更新所有例程的数据？”

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

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

因此，请注意，您的辅助函数在每个goroutine实例内的同一通道上执行发送和接收。如果您只有一个这样的辅助函数实例，这将导致死锁

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

因此，如果工作进程不能读写同一个通道，那么它必须使用一个特定的可写通道来将其结果发送给其他一些例程

//我想等到所有的例程在通道和
从工作人员返回数据

这是同步机制的一部分，需要确保推送程序等待所有工作人员完成工作后才能继续

//正确地说，这将关闭通道，在我收到错误发送后，在这里
封闭通道

请注意，您有n个并行执行的工作线程例程。此工作线程中第一个到达其函数末尾的将关闭通道，使其对其他工作线程不可写入，并向main发送错误的结束信号

通常，在写入端使用close语句表示通道中没有更多数据。表示通道已结束。此信号由读卡器使用
    for data := range c {
        fmt.Println(data)
    }