我創建了一個最小的可復制示例
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("-:-:-", 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("-:-:-", 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)
}
本質上，我有兩個不同的服務，它們record在兩個不同的 goroutine中運行一個方法。他們每個人都在不同的時間創建并寫入不同的 csv 檔案。當我運行它時，會創建 csv 檔案但從未有資料。運行此程式時不會出現任何錯誤。我讀到我應該使用我已經實作的互斥鎖，但這也不起作用。我應該在這里做什么？
uj5u.com熱心網友回復：
如注釋中所述，程式將在main()完成時退出；規范指出“它不會等待其他（非主）goroutine 完成。”。
這意味著您的 go 例程不太可能處理關閉檔案的代碼，這意味著可能不會寫入緩沖資料。
我創建了應用程式的簡化版本，操場上證明這一點。
有多種方法可以解決此問題，但最簡單的方法可能是添加一個，WaitGroup以便您的應用程式可以在終止之前等待 go 例程退出。
轉載請註明出處，本文鏈接：https://www.uj5u.com/caozuo/347823.html