Go 海峡虽已关闭，但永不消亡

在下面的代码中，我试图写入发送到

输入

通道的所有文件，并通过

操作输出

通道发送相应的响应

main.go

package main

import(
    lr "github.com/fabulousduck/librarian"
    "fmt"
)

func main() {
    writeOpCount := 100;
    operationOutcomes, inputs := make(chan lr.WriteOpResponse), make(chan lr.WriteOp)
    go lr.WriteC(inputs, operationOutcomes)

    for i := 0; i < writeOpCount; i++ {
        inputs <- lr.WriteOp{ Dest: `../exampleFiles/createdFiles/{i}.txt`, Content: `Invoice #{i}` }
    }

    close(inputs)  

    for i := 0; i < writeOpCount; i++ {
        writeResult := <-operationOutcomes
        fmt.Println("Response from write operation : ", writeResult.Msg, "err ", writeResult.Err, "bytes written : ", writeResult.BytesWritten)
    }

    close(operationOutcomes)
}

主程序包
进口(
lr“github.com/fabuluduck/librarian”
“fmt”
)
func main（）{
WriteOpount:=100；
操作输出，输入：=make（chan-lr.WriteOp响应），make（chan-lr.WriteOp）
go lr.WriteC（输入、操作输出）
对于i:=0；i输入您只能从
操作中读取输出
多达
WriteCount
次，即使在
writeWorker
中，每次执行最多可在该通道上写入3条消息（您的任何错误情况都不会导致函数返回，它将继续处理）。因为它是无缓冲的，并且不再被读取，在某个时候，向它写入的工作人员无法再添加消息，因此会永久锁定

此外，由于您只调用
WriteC
一次，并且它不会循环，因此它只会从
输入中读取和处理一条消息。如果
writeopount
为>1，则当它尝试将第二条消息排队时，它将永远锁定在第一个循环中。
作为注释，因为它与q无关，因为WriteC是already被称为goroutine，为什么它会启动另一个goroutine来调用
writeWorker
？因为您可能希望在代码的其他部分中添加多个彼此不相关的
writeC
实例。我确实注意到了这一点，并尝试在每次推送到频道后添加
return
语句。然而，这确实是可行的没有解决问题。更新-发现第二个问题。非常感谢。第二个问题解决了我的问题。
import(
    "os"
    "fmt"
)

type WriteOp struct {
    Dest, Content string
}

type WriteOpResponse struct {
    Msg error
    Err bool
    BytesWritten int
}

func WriteC (inputChannel <-chan WriteOp, outputChannel chan<- WriteOpResponse) {
    workOp :=  <-inputChannel
    go writeWorker(workOp, outputChannel)
}

func writeWorker (job WriteOp, outGoing chan<- WriteOpResponse) {
    file, err := os.OpenFile(job.Dest, os.O_RDWR, 0666)
    if err != nil {
        fmt.Println("err : ", err)
        outGoing <- WriteOpResponse{ Msg: err, Err: true, BytesWritten: 0 }
    }
    bytesWritten , err := file.WriteString(job.Content)
    if err != nil {
        outGoing <- WriteOpResponse{ Msg: err, Err: true, BytesWritten: 0 }
    }
    outGoing <- WriteOpResponse{ Msg: nil, Err: false, BytesWritten: bytesWritten } 
}