在Go语言中如何一次性写入两个不同的csv文件？

目前golang学习网上已经有很多关于Golang的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《在Go语言中如何一次性写入两个不同的csv文件？》，也希望能帮助到大家，如果阅读完后真的对你学习Golang有帮助，欢迎动动手指，评论留言并分享~

我创建了一个最小的可复制示例

package main

import (
    "encoding/csv"
    "fmt"
    "os"
    "strconv"
    "sync/atomic"
    "time"
)

var (
    csvOnePath = "test.csv"
    csvTwoPath = "test_two.csv"
)

type A struct {
    Running     int32 // used atomically
    QuitChan    chan struct{}
}

func NewA() *A {
    return &A{
        QuitChan: make(chan struct{}),
    }
}

func (a *A) Start() error {
    if ok := atomic.CompareAndSwapInt32(&a.Running, 0, 1); !ok {
        return fmt.Errorf("Cannot start service A: service already started")
    }
    go a.record()
    return nil
}

func (a *A) Stop() error {
    if ok := atomic.CompareAndSwapInt32(&a.Running, 1, 0); !ok {
        return fmt.Errorf("Cannot stop service A: service already stopped")
    }
    close(a.QuitChan)
    return nil
}

func (a *A) record() {
    //file_one, err := os.OpenFile(csvOnePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0755)
    file_one, err := os.Create(csvOnePath)
    if err != nil {
        fmt.Println(err)
        return
    }
    writer := csv.NewWriter(file_one)
    // writer, closeFileFunc, err := NewCsvWriter(csvOnePath)
    if err != nil {
        fmt.Println(err)
        return
    }
    header := []string{"this", "is", "a", "test"}
    err = writer.Write(header)
    if err != nil {
        fmt.Println(err)
        return
    }
    ticker := time.NewTicker(10*time.Second)
    for {
        select {
        case t := <-ticker.C:
            err = writer.Write([]string{fmt.Sprintf("%2d:%2d:%2d", t.Hour(), t.Minute(), t.Second())})
            if err != nil {
                fmt.Println(err)
                a.QuitChan <- struct{}{}
            }
        case <-a.QuitChan:
            ticker.Stop()
            writer.Flush()
            file_one.Close()
            fmt.Println("Stopped recording.")
            break
        }
    }
}

type B struct {
    Running     int32 // used atomically
    QuitChan    chan struct{}
}

func NewB() *B {
    return &B{
        QuitChan: make(chan struct{}),
    }
}

func (b *B) Start() error {
    if ok := atomic.CompareAndSwapInt32(&b.Running, 0, 1); !ok {
        return fmt.Errorf("Cannot start service B: service already started")
    }
    go b.record()
    return nil
}

func (b *B) Stop() error {
    if ok := atomic.CompareAndSwapInt32(&b.Running, 1, 0); !ok {
        return fmt.Errorf("Cannot stop service B: service already stopped")
    }
    close(b.QuitChan)
    return nil
}

func writeMsgToReport(report *csv.Writer, msg string) error {
    ct := time.Now()
    timestamp := fmt.Sprintf("%2d:%2d:%2d", ct.Hour(), ct.Minute(), ct.Second())
    return report.Write([]string{timestamp, msg})
}

func (b *B) record() {
    //file_two, err := os.OpenFile(csvTwoPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)
    file_two, err := os.Create(csvTwoPath)
    if err != nil {
        fmt.Println(err)
        return
    }
    writer := csv.NewWriter(file_two)
    //writer, closeFileFunc, err := NewCsvWriter(csvTwoPath)
    if err != nil {
        fmt.Println(err)
        return
    }
    header := []string{"this", "is", "a", "second", "test"}
    err = writer.Write(header)
    if err != nil {
        fmt.Println(err)
        return
    }
    ticker := time.NewTicker(1*time.Second)
    ticks := 0
    for {
        select {
        case <-ticker.C:
            if ticks % 15 == 0 {
                err = writeMsgToReport(writer, "YEET "+strconv.Itoa(ticks))
                if err != nil {
                    fmt.Println(err)
                    b.QuitChan <- struct{}{}
                }
            }
            ticks++
        case <-b.QuitChan:
            ticker.Stop()
            writer.Flush()
            file_two.Close()
            fmt.Println("Stopped recording.")
            break
        }
    }
}

func main() {
    serviceA := NewA()
    err := serviceA.Start()
    if err != nil {
        fmt.Println(err)
        return
    }
    defer serviceA.Stop()
    serviceB := NewB()
    err = serviceB.Start()
    if err != nil {
        fmt.Println(err)
        return
    }
    defer serviceB.Stop()
    time.Sleep(600*time.Second)
}

本质上，我有两个不同的服务，它们在两个不同的 goroutine 中运行 record 方法。他们各自在不同时间创建并写入不同的 csv 文件。当我运行此命令时，会创建 csv 文件，但从未有数据。运行此程序时不会出现任何错误。我读到我应该使用我已经实现的互斥锁，但这也不起作用。我应该在这里做什么？

正确答案

如注释中所述，当 main() 完成时，程序将退出； the spec 指出“它不会等待其他（非主）goroutine 完成。”。

这意味着您的 go 例程不太可能处理关闭文件的代码，这意味着缓冲数据可能不会被写入。

我在 the playground 中创建了您的应用程序的简化版本来演示这一点。

有多种方法可以解决此问题，但最简单的可能是添加 WaitGroup，以便您的应用程序可以在终止之前等待 go 例程退出。

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~