将 csv.NewWriter() 传递给 Golang 中的另一个函数以异步写入文件

Question

我正在进行 API 次调用（在一个作业中可能有数千次）并且当它们返回并完成时，我希望能够将它们写入单个共享文件（为简单起见说 CSV）而不是等待它们全部完成在写作之前。

我怎样才能以有效写入由多个线程共享的单个文件的方式共享单个csv.Writer() 。 这可能是一项艰巨的任务，但我很好奇是否有办法 go 了解一下。

package main
import (
    "encoding/csv"
    "os"
)

type Row struct {
    Field1 string
    Field2 string
}

func main () {
    file, _ := os.Create("file.csv")
    w := csv.NewWriter(file)

    // Some operations to create a slice of Row structs that will contain the rows 
    // To write
    var rowsToWrite []Row
    // Now lets iterate over and write to file
    // Ideally, I'd like to do this in a goroutine but not entirely sure about thread safe writes
    for _, r := range rowsToWrite {
        go func(row, writer) {
            err := writeToFile(row, writer)
            if err != nil {
            // Handle error
            }
        }(r, w)
    }

}

func writeToFile(row Row, writer ???) error {

    // Use the shared writer to maintain where I am at in the file so I can append to the CSV
    if err := w.Write(row); err != nil {
        return err
    }
    return nil

}

Answer 1

我（个人）不会在代码的两个不同点打开同一个文件进行写入。 根据操作系统处理缓冲写入等的方式，您最终可能会发生“有趣”的事情。

鉴于您如何描述您的目标，人们可能会做类似的事情（这是我的头脑并且没有经过严格测试）：

1. 创建一个通道来排队要写入的文本块（我假设）- make(chan []byte, depth) - depth可以根据您运行的一些测试进行调整，大概。
2. 让一个 goroutine 打开一个文件句柄以写入您的文件，然后从该排队通道读取，并将从该通道获得的任何内容写入该文件
3. 然后你可以让n 个goroutines 写入排队通道，只要你不超过通道容量（超出你的写入能力），你可能永远不需要担心锁。

如果您确实想使用锁，那么您需要在负责入队的 goroutine 之间共享一个sync.Mutex 。

显然，调味。

Answer 2

对我来说很多来回

我最初认为您可以在 goroutine 中的 csv.Writer 上使用 Write() 方法，但是在写入缓冲区时缓冲区刷新到磁盘时会出现问题......不太确定。

无论如何，回到你最初的要求......

仍然使用相同的设置从https://jsonplaceholder.typicode.com下载 Todo 对象，例如：

type Todo struct {
    UserID    int    `json:"userId"`
    ID        int    `json:"id"`
    Title     string `json:"title"`
    Completed bool   `json:"completed"`
}

// toRecord converts Todo struct to []string, for writing to CSV.
func (t Todo) toRecord() []string {
    userID := strconv.Itoa(t.UserID)
    id := strconv.Itoa(t.ID)
    completed := strconv.FormatBool(t.Completed)

    return []string{userID, id, t.Title, completed}
}

// getTodo gets endpoint and unmarshalls the response JSON into todo.
func getTodo(endpoint string) (todo Todo) {
    resp, err := http.Get(endpoint)
    if err != nil {
        log.Println("error:", err)
    }
    defer resp.Body.Close()
    json.NewDecoder(resp.Body).Decode(&todo)
    return
}

下列：

• 将启动一个“父”goroutine 来开始填充todos通道：
  • 在该例程中，将为每个 HTTP 请求启动 goroutines，并将响应 Todo 发送到todos
  • 父母将等到所有请求例程完成
  • 完成后，父母将关闭todos频道
• 同时， main 继续前进并遍历todos ，一次选择一个 Todo 并将其写入 CSV。
• 当原始的“父”goroutine 最终关闭todos时，for 循环将中断，编写器执行最终的 Flush()，程序将完成。

func main() {
    todos := make(chan Todo)

    go func() {
        const nAPICalls = 200
        var wg sync.WaitGroup

        wg.Add(nAPICalls)
        for i := 0; i < nAPICalls; i++ {
            s := fmt.Sprintf("https://jsonplaceholder.typicode.com/todos/%d", i+1)

            go func(x string) {
                todos <- getTodo(x)
                wg.Done()
            }(s)
        }
        wg.Wait()

        close(todos)
    }()

    w := csv.NewWriter(os.Stdout)
    w.Write([]string{"UserID", "ID", "Title", "Completed"})
    for todo := range todos {
        w.Write(todo.toRecord())
    }
    w.Flush()
}